home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / lib / gcc-lib / ppc-amigaos / 2.95.1 / sys-include / powerup / ppcpragmas / intuition_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-03-13  |  75KB  |  2,469 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_INTUITION_H
  4. #define _PPCPRAGMA_INTUITION_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__INTUITION_H
  7. #include <powerup/ppcinline/intuition.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef INTUITION_BASE_NAME
  24. #define INTUITION_BASE_NAME IntuitionBase
  25. #endif /* !INTUITION_BASE_NAME */
  26.  
  27. #define    ActivateGadget(gadgets, window, requester)    _ActivateGadget(INTUITION_BASE_NAME, gadgets, window, requester)
  28.  
  29. static __inline BOOL
  30. _ActivateGadget(void *IntuitionBase, struct Gadget *gadgets, struct Window *window, struct Requester *requester)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a0        =(ULONG) gadgets;
  40.     MyCaos.a1        =(ULONG) window;
  41.     MyCaos.a2        =(ULONG) requester;
  42.     MyCaos.caos_Un.Offset    =    (-462);
  43.     MyCaos.a6        =(ULONG) IntuitionBase;    
  44.     return((BOOL)PPCCallOS(&MyCaos));
  45. }
  46.  
  47. #define    ActivateWindow(window)    _ActivateWindow(INTUITION_BASE_NAME, window)
  48.  
  49. static __inline void
  50. _ActivateWindow(void *IntuitionBase, struct Window *window)
  51. {
  52. struct Caos    MyCaos;
  53.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  54. //    MyCaos.M68kStart    =    NULL;
  55. //    MyCaos.M68kSize        =    0;
  56.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  57. //    MyCaos.PPCStart        =    NULL;
  58. //    MyCaos.PPCSize        =    0;
  59.     MyCaos.a0        =(ULONG) window;
  60.     MyCaos.caos_Un.Offset    =    (-450);
  61.     MyCaos.a6        =(ULONG) IntuitionBase;    
  62.     PPCCallOS(&MyCaos);
  63. }
  64.  
  65. #define    AddClass(classPtr)    _AddClass(INTUITION_BASE_NAME, classPtr)
  66.  
  67. static __inline void
  68. _AddClass(void *IntuitionBase, struct IClass *classPtr)
  69. {
  70. struct Caos    MyCaos;
  71.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  72. //    MyCaos.M68kStart    =    NULL;
  73. //    MyCaos.M68kSize        =    0;
  74.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  75. //    MyCaos.PPCStart        =    NULL;
  76. //    MyCaos.PPCSize        =    0;
  77.     MyCaos.a0        =(ULONG) classPtr;
  78.     MyCaos.caos_Un.Offset    =    (-684);
  79.     MyCaos.a6        =(ULONG) IntuitionBase;    
  80.     PPCCallOS(&MyCaos);
  81. }
  82.  
  83. #define    AddGList(window, gadget, position, numGad, requester)    _AddGList(INTUITION_BASE_NAME, window, gadget, position, numGad, requester)
  84.  
  85. static __inline UWORD
  86. _AddGList(void *IntuitionBase, struct Window *window, struct Gadget *gadget, unsigned long position, long numGad, struct Requester *requester)
  87. {
  88. struct Caos    MyCaos;
  89.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  90. //    MyCaos.M68kStart    =    NULL;
  91. //    MyCaos.M68kSize        =    0;
  92.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  93. //    MyCaos.PPCStart        =    NULL;
  94. //    MyCaos.PPCSize        =    0;
  95.     MyCaos.a0        =(ULONG) window;
  96.     MyCaos.a1        =(ULONG) gadget;
  97.     MyCaos.d0        =(ULONG) position;
  98.     MyCaos.d1        =(ULONG) numGad;
  99.     MyCaos.a2        =(ULONG) requester;
  100.     MyCaos.caos_Un.Offset    =    (-438);
  101.     MyCaos.a6        =(ULONG) IntuitionBase;    
  102.     return((UWORD)PPCCallOS(&MyCaos));
  103. }
  104.  
  105. #define    AddGadget(window, gadget, position)    _AddGadget(INTUITION_BASE_NAME, window, gadget, position)
  106.  
  107. static __inline UWORD
  108. _AddGadget(void *IntuitionBase, struct Window *window, struct Gadget *gadget, unsigned long position)
  109. {
  110. struct Caos    MyCaos;
  111.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  112. //    MyCaos.M68kStart    =    NULL;
  113. //    MyCaos.M68kSize        =    0;
  114.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  115. //    MyCaos.PPCStart        =    NULL;
  116. //    MyCaos.PPCSize        =    0;
  117.     MyCaos.a0        =(ULONG) window;
  118.     MyCaos.a1        =(ULONG) gadget;
  119.     MyCaos.d0        =(ULONG) position;
  120.     MyCaos.caos_Un.Offset    =    (-42);
  121.     MyCaos.a6        =(ULONG) IntuitionBase;    
  122.     return((UWORD)PPCCallOS(&MyCaos));
  123. }
  124.  
  125. #define    AllocRemember(rememberKey, size, flags)    _AllocRemember(INTUITION_BASE_NAME, rememberKey, size, flags)
  126.  
  127. static __inline APTR
  128. _AllocRemember(void *IntuitionBase, struct Remember **rememberKey, unsigned long size, unsigned long flags)
  129. {
  130. struct Caos    MyCaos;
  131.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  132. //    MyCaos.M68kStart    =    NULL;
  133. //    MyCaos.M68kSize        =    0;
  134.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  135. //    MyCaos.PPCStart        =    NULL;
  136. //    MyCaos.PPCSize        =    0;
  137.     MyCaos.a0        =(ULONG) rememberKey;
  138.     MyCaos.d0        =(ULONG) size;
  139.     MyCaos.d1        =(ULONG) flags;
  140.     MyCaos.caos_Un.Offset    =    (-396);
  141.     MyCaos.a6        =(ULONG) IntuitionBase;    
  142.     return((APTR)PPCCallOS(&MyCaos));
  143. }
  144.  
  145. #define    AllocScreenBuffer(sc, bm, flags)    _AllocScreenBuffer(INTUITION_BASE_NAME, sc, bm, flags)
  146.  
  147. static __inline struct ScreenBuffer *
  148. _AllocScreenBuffer(void *IntuitionBase, struct Screen *sc, struct BitMap *bm, unsigned long flags)
  149. {
  150. struct Caos    MyCaos;
  151.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  152. //    MyCaos.M68kStart    =    NULL;
  153. //    MyCaos.M68kSize        =    0;
  154.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  155. //    MyCaos.PPCStart        =    NULL;
  156. //    MyCaos.PPCSize        =    0;
  157.     MyCaos.a0        =(ULONG) sc;
  158.     MyCaos.a1        =(ULONG) bm;
  159.     MyCaos.d0        =(ULONG) flags;
  160.     MyCaos.caos_Un.Offset    =    (-768);
  161.     MyCaos.a6        =(ULONG) IntuitionBase;    
  162.     return((struct ScreenBuffer *)PPCCallOS(&MyCaos));
  163. }
  164.  
  165. #define    AlohaWorkbench(wbport)    _AlohaWorkbench(INTUITION_BASE_NAME, wbport)
  166.  
  167. static __inline void
  168. _AlohaWorkbench(void *IntuitionBase, long wbport)
  169. {
  170. struct Caos    MyCaos;
  171.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  172. //    MyCaos.M68kStart    =    NULL;
  173. //    MyCaos.M68kSize        =    0;
  174.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  175. //    MyCaos.PPCStart        =    NULL;
  176. //    MyCaos.PPCSize        =    0;
  177.     MyCaos.a0        =(ULONG) wbport;
  178.     MyCaos.caos_Un.Offset    =    (-402);
  179.     MyCaos.a6        =(ULONG) IntuitionBase;    
  180.     PPCCallOS(&MyCaos);
  181. }
  182.  
  183. #define    AutoRequest(window, body, posText, negText, pFlag, nFlag, width, height)    _AutoRequest(INTUITION_BASE_NAME, window, body, posText, negText, pFlag, nFlag, width, height)
  184.  
  185. static __inline BOOL
  186. _AutoRequest(void *IntuitionBase, struct Window *window, struct IntuiText *body, struct IntuiText *posText, struct IntuiText *negText, unsigned long pFlag, unsigned long nFlag, unsigned long width, unsigned long height)
  187. {
  188. struct Caos    MyCaos;
  189.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  190. //    MyCaos.M68kStart    =    NULL;
  191. //    MyCaos.M68kSize        =    0;
  192.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  193. //    MyCaos.PPCStart        =    NULL;
  194. //    MyCaos.PPCSize        =    0;
  195.     MyCaos.a0        =(ULONG) window;
  196.     MyCaos.a1        =(ULONG) body;
  197.     MyCaos.a2        =(ULONG) posText;
  198.     MyCaos.a3        =(ULONG) negText;
  199.     MyCaos.d0        =(ULONG) pFlag;
  200.     MyCaos.d1        =(ULONG) nFlag;
  201.     MyCaos.d2        =(ULONG) width;
  202.     MyCaos.d3        =(ULONG) height;
  203.     MyCaos.caos_Un.Offset    =    (-348);
  204.     MyCaos.a6        =(ULONG) IntuitionBase;    
  205.     return((BOOL)PPCCallOS(&MyCaos));
  206. }
  207.  
  208. #define    BeginRefresh(window)    _BeginRefresh(INTUITION_BASE_NAME, window)
  209.  
  210. static __inline void
  211. _BeginRefresh(void *IntuitionBase, struct Window *window)
  212. {
  213. struct Caos    MyCaos;
  214.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  215. //    MyCaos.M68kStart    =    NULL;
  216. //    MyCaos.M68kSize        =    0;
  217.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  218. //    MyCaos.PPCStart        =    NULL;
  219. //    MyCaos.PPCSize        =    0;
  220.     MyCaos.a0        =(ULONG) window;
  221.     MyCaos.caos_Un.Offset    =    (-354);
  222.     MyCaos.a6        =(ULONG) IntuitionBase;    
  223.     PPCCallOS(&MyCaos);
  224. }
  225.  
  226. #define    BuildEasyRequestArgs(window, easyStruct, idcmp, args)    _BuildEasyRequestArgs(INTUITION_BASE_NAME, window, easyStruct, idcmp, args)
  227.  
  228. static __inline struct Window *
  229. _BuildEasyRequestArgs(void *IntuitionBase, struct Window *window, struct EasyStruct *easyStruct, unsigned long idcmp, APTR args)
  230. {
  231. struct Caos    MyCaos;
  232.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  233. //    MyCaos.M68kStart    =    NULL;
  234. //    MyCaos.M68kSize        =    0;
  235.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  236. //    MyCaos.PPCStart        =    NULL;
  237. //    MyCaos.PPCSize        =    0;
  238.     MyCaos.a0        =(ULONG) window;
  239.     MyCaos.a1        =(ULONG) easyStruct;
  240.     MyCaos.d0        =(ULONG) idcmp;
  241.     MyCaos.a3        =(ULONG) args;
  242.     MyCaos.caos_Un.Offset    =    (-594);
  243.     MyCaos.a6        =(ULONG) IntuitionBase;    
  244.     return((struct Window *)PPCCallOS(&MyCaos));
  245. }
  246.  
  247. #ifndef NO_PPCINLINE_STDARG
  248. #define BuildEasyRequest(a0, a1, a2, tags...) \
  249.     ({ULONG _tags[] = { tags }; BuildEasyRequestArgs((a0), (a1), (a2), (APTR)_tags);})
  250. #endif /* !NO_PPCINLINE_STDARG */
  251.  
  252. #define    BuildSysRequest(window, body, posText, negText, flags, width, height)    _BuildSysRequest(INTUITION_BASE_NAME, window, body, posText, negText, flags, width, height)
  253.  
  254. static __inline struct Window *
  255. _BuildSysRequest(void *IntuitionBase, struct Window *window, struct IntuiText *body, struct IntuiText *posText, struct IntuiText *negText, unsigned long flags, unsigned long width, unsigned long height)
  256. {
  257. struct Caos    MyCaos;
  258.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  259. //    MyCaos.M68kStart    =    NULL;
  260. //    MyCaos.M68kSize        =    0;
  261.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  262. //    MyCaos.PPCStart        =    NULL;
  263. //    MyCaos.PPCSize        =    0;
  264.     MyCaos.a0        =(ULONG) window;
  265.     MyCaos.a1        =(ULONG) body;
  266.     MyCaos.a2        =(ULONG) posText;
  267.     MyCaos.a3        =(ULONG) negText;
  268.     MyCaos.d0        =(ULONG) flags;
  269.     MyCaos.d1        =(ULONG) width;
  270.     MyCaos.d2        =(ULONG) height;
  271.     MyCaos.caos_Un.Offset    =    (-360);
  272.     MyCaos.a6        =(ULONG) IntuitionBase;    
  273.     return((struct Window *)PPCCallOS(&MyCaos));
  274. }
  275.  
  276. #define    ChangeScreenBuffer(sc, sb)    _ChangeScreenBuffer(INTUITION_BASE_NAME, sc, sb)
  277.  
  278. static __inline ULONG
  279. _ChangeScreenBuffer(void *IntuitionBase, struct Screen *sc, struct ScreenBuffer *sb)
  280. {
  281. struct Caos    MyCaos;
  282.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  283. //    MyCaos.M68kStart    =    NULL;
  284. //    MyCaos.M68kSize        =    0;
  285.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  286. //    MyCaos.PPCStart        =    NULL;
  287. //    MyCaos.PPCSize        =    0;
  288.     MyCaos.a0        =(ULONG) sc;
  289.     MyCaos.a1        =(ULONG) sb;
  290.     MyCaos.caos_Un.Offset    =    (-780);
  291.     MyCaos.a6        =(ULONG) IntuitionBase;    
  292.     return((ULONG)PPCCallOS(&MyCaos));
  293. }
  294.  
  295. #define    ChangeWindowBox(window, left, top, width, height)    _ChangeWindowBox(INTUITION_BASE_NAME, window, left, top, width, height)
  296.  
  297. static __inline void
  298. _ChangeWindowBox(void *IntuitionBase, struct Window *window, long left, long top, long width, long height)
  299. {
  300. struct Caos    MyCaos;
  301.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  302. //    MyCaos.M68kStart    =    NULL;
  303. //    MyCaos.M68kSize        =    0;
  304.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  305. //    MyCaos.PPCStart        =    NULL;
  306. //    MyCaos.PPCSize        =    0;
  307.     MyCaos.a0        =(ULONG) window;
  308.     MyCaos.d0        =(ULONG) left;
  309.     MyCaos.d1        =(ULONG) top;
  310.     MyCaos.d2        =(ULONG) width;
  311.     MyCaos.d3        =(ULONG) height;
  312.     MyCaos.caos_Un.Offset    =    (-486);
  313.     MyCaos.a6        =(ULONG) IntuitionBase;    
  314.     PPCCallOS(&MyCaos);
  315. }
  316.  
  317. #define    ClearDMRequest(window)    _ClearDMRequest(INTUITION_BASE_NAME, window)
  318.  
  319. static __inline BOOL
  320. _ClearDMRequest(void *IntuitionBase, struct Window *window)
  321. {
  322. struct Caos    MyCaos;
  323.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  324. //    MyCaos.M68kStart    =    NULL;
  325. //    MyCaos.M68kSize        =    0;
  326.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  327. //    MyCaos.PPCStart        =    NULL;
  328. //    MyCaos.PPCSize        =    0;
  329.     MyCaos.a0        =(ULONG) window;
  330.     MyCaos.caos_Un.Offset    =    (-48);
  331.     MyCaos.a6        =(ULONG) IntuitionBase;    
  332.     return((BOOL)PPCCallOS(&MyCaos));
  333. }
  334.  
  335. #define    ClearMenuStrip(window)    _ClearMenuStrip(INTUITION_BASE_NAME, window)
  336.  
  337. static __inline void
  338. _ClearMenuStrip(void *IntuitionBase, struct Window *window)
  339. {
  340. struct Caos    MyCaos;
  341.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  342. //    MyCaos.M68kStart    =    NULL;
  343. //    MyCaos.M68kSize        =    0;
  344.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  345. //    MyCaos.PPCStart        =    NULL;
  346. //    MyCaos.PPCSize        =    0;
  347.     MyCaos.a0        =(ULONG) window;
  348.     MyCaos.caos_Un.Offset    =    (-54);
  349.     MyCaos.a6        =(ULONG) IntuitionBase;    
  350.     PPCCallOS(&MyCaos);
  351. }
  352.  
  353. #define    ClearPointer(window)    _ClearPointer(INTUITION_BASE_NAME, window)
  354.  
  355. static __inline void
  356. _ClearPointer(void *IntuitionBase, struct Window *window)
  357. {
  358. struct Caos    MyCaos;
  359.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  360. //    MyCaos.M68kStart    =    NULL;
  361. //    MyCaos.M68kSize        =    0;
  362.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  363. //    MyCaos.PPCStart        =    NULL;
  364. //    MyCaos.PPCSize        =    0;
  365.     MyCaos.a0        =(ULONG) window;
  366.     MyCaos.caos_Un.Offset    =    (-60);
  367.     MyCaos.a6        =(ULONG) IntuitionBase;    
  368.     PPCCallOS(&MyCaos);
  369. }
  370.  
  371. #define    CloseScreen(screen)    _CloseScreen(INTUITION_BASE_NAME, screen)
  372.  
  373. static __inline BOOL
  374. _CloseScreen(void *IntuitionBase, struct Screen *screen)
  375. {
  376. struct Caos    MyCaos;
  377.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  378. //    MyCaos.M68kStart    =    NULL;
  379. //    MyCaos.M68kSize        =    0;
  380.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  381. //    MyCaos.PPCStart        =    NULL;
  382. //    MyCaos.PPCSize        =    0;
  383.     MyCaos.a0        =(ULONG) screen;
  384.     MyCaos.caos_Un.Offset    =    (-66);
  385.     MyCaos.a6        =(ULONG) IntuitionBase;    
  386.     return((BOOL)PPCCallOS(&MyCaos));
  387. }
  388.  
  389. #define    CloseWindow(window)    _CloseWindow(INTUITION_BASE_NAME, window)
  390.  
  391. static __inline void
  392. _CloseWindow(void *IntuitionBase, struct Window *window)
  393. {
  394. struct Caos    MyCaos;
  395.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  396. //    MyCaos.M68kStart    =    NULL;
  397. //    MyCaos.M68kSize        =    0;
  398.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  399. //    MyCaos.PPCStart        =    NULL;
  400. //    MyCaos.PPCSize        =    0;
  401.     MyCaos.a0        =(ULONG) window;
  402.     MyCaos.caos_Un.Offset    =    (-72);
  403.     MyCaos.a6        =(ULONG) IntuitionBase;    
  404.     PPCCallOS(&MyCaos);
  405. }
  406.  
  407. #define    CloseWorkBench()    _CloseWorkBench(INTUITION_BASE_NAME)
  408.  
  409. static __inline LONG
  410. _CloseWorkBench(void *IntuitionBase)
  411. {
  412. struct Caos    MyCaos;
  413.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  414. //    MyCaos.M68kStart    =    NULL;
  415. //    MyCaos.M68kSize        =    0;
  416.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  417. //    MyCaos.PPCStart        =    NULL;
  418. //    MyCaos.PPCSize        =    0;
  419.     MyCaos.caos_Un.Offset    =    (-78);
  420.     MyCaos.a6        =(ULONG) IntuitionBase;    
  421.     return((LONG)PPCCallOS(&MyCaos));
  422. }
  423.  
  424. #define    CurrentTime(seconds, micros)    _CurrentTime(INTUITION_BASE_NAME, seconds, micros)
  425.  
  426. static __inline void
  427. _CurrentTime(void *IntuitionBase, ULONG *seconds, ULONG *micros)
  428. {
  429. struct Caos    MyCaos;
  430.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  431. //    MyCaos.M68kStart    =    NULL;
  432. //    MyCaos.M68kSize        =    0;
  433.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  434. //    MyCaos.PPCStart        =    NULL;
  435. //    MyCaos.PPCSize        =    0;
  436.     MyCaos.a0        =(ULONG) seconds;
  437.     MyCaos.a1        =(ULONG) micros;
  438.     MyCaos.caos_Un.Offset    =    (-84);
  439.     MyCaos.a6        =(ULONG) IntuitionBase;    
  440.     PPCCallOS(&MyCaos);
  441. }
  442.  
  443. #define    DisplayAlert(alertNumber, string, height)    _DisplayAlert(INTUITION_BASE_NAME, alertNumber, string, height)
  444.  
  445. static __inline BOOL
  446. _DisplayAlert(void *IntuitionBase, unsigned long alertNumber, UBYTE *string, unsigned long height)
  447. {
  448. struct Caos    MyCaos;
  449.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  450. //    MyCaos.M68kStart    =    NULL;
  451. //    MyCaos.M68kSize        =    0;
  452.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  453. //    MyCaos.PPCStart        =    NULL;
  454. //    MyCaos.PPCSize        =    0;
  455.     MyCaos.d0        =(ULONG) alertNumber;
  456.     MyCaos.a0        =(ULONG) string;
  457.     MyCaos.d1        =(ULONG) height;
  458.     MyCaos.caos_Un.Offset    =    (-90);
  459.     MyCaos.a6        =(ULONG) IntuitionBase;    
  460.     return((BOOL)PPCCallOS(&MyCaos));
  461. }
  462.  
  463. #define    DisplayBeep(screen)    _DisplayBeep(INTUITION_BASE_NAME, screen)
  464.  
  465. static __inline void
  466. _DisplayBeep(void *IntuitionBase, struct Screen *screen)
  467. {
  468. struct Caos    MyCaos;
  469.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  470. //    MyCaos.M68kStart    =    NULL;
  471. //    MyCaos.M68kSize        =    0;
  472.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  473. //    MyCaos.PPCStart        =    NULL;
  474. //    MyCaos.PPCSize        =    0;
  475.     MyCaos.a0        =(ULONG) screen;
  476.     MyCaos.caos_Un.Offset    =    (-96);
  477.     MyCaos.a6        =(ULONG) IntuitionBase;    
  478.     PPCCallOS(&MyCaos);
  479. }
  480.  
  481. #define    DisposeObject(object)    _DisposeObject(INTUITION_BASE_NAME, object)
  482.  
  483. static __inline void
  484. _DisposeObject(void *IntuitionBase, APTR object)
  485. {
  486. struct Caos    MyCaos;
  487.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  488. //    MyCaos.M68kStart    =    NULL;
  489. //    MyCaos.M68kSize        =    0;
  490.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  491. //    MyCaos.PPCStart        =    NULL;
  492. //    MyCaos.PPCSize        =    0;
  493.     MyCaos.a0        =(ULONG) object;
  494.     MyCaos.caos_Un.Offset    =    (-642);
  495.     MyCaos.a6        =(ULONG) IntuitionBase;    
  496.     PPCCallOS(&MyCaos);
  497. }
  498.  
  499. #define    DoGadgetMethodA(gad, win, req, message)    _DoGadgetMethodA(INTUITION_BASE_NAME, gad, win, req, message)
  500.  
  501. static __inline ULONG
  502. _DoGadgetMethodA(void *IntuitionBase, struct Gadget *gad, struct Window *win, struct Requester *req, Msg message)
  503. {
  504. struct Caos    MyCaos;
  505.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  506. //    MyCaos.M68kStart    =    NULL;
  507. //    MyCaos.M68kSize        =    0;
  508.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  509. //    MyCaos.PPCStart        =    NULL;
  510. //    MyCaos.PPCSize        =    0;
  511.     MyCaos.a0        =(ULONG) gad;
  512.     MyCaos.a1        =(ULONG) win;
  513.     MyCaos.a2        =(ULONG) req;
  514.     MyCaos.a3        =(ULONG) message;
  515.     MyCaos.caos_Un.Offset    =    (-810);
  516.     MyCaos.a6        =(ULONG) IntuitionBase;    
  517.     return((ULONG)PPCCallOS(&MyCaos));
  518. }
  519.  
  520. #ifndef NO_PPCINLINE_STDARG
  521. #define DoGadgetMethod(a0, a1, a2, tags...) \
  522.     ({ULONG _tags[] = { tags }; DoGadgetMethodA((a0), (a1), (a2), (Msg)_tags);})
  523. #endif /* !NO_PPCINLINE_STDARG */
  524.  
  525. #define    DoubleClick(sSeconds, sMicros, cSeconds, cMicros)    _DoubleClick(INTUITION_BASE_NAME, sSeconds, sMicros, cSeconds, cMicros)
  526.  
  527. static __inline BOOL
  528. _DoubleClick(void *IntuitionBase, unsigned long sSeconds, unsigned long sMicros, unsigned long cSeconds, unsigned long cMicros)
  529. {
  530. struct Caos    MyCaos;
  531.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  532. //    MyCaos.M68kStart    =    NULL;
  533. //    MyCaos.M68kSize        =    0;
  534.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  535. //    MyCaos.PPCStart        =    NULL;
  536. //    MyCaos.PPCSize        =    0;
  537.     MyCaos.d0        =(ULONG) sSeconds;
  538.     MyCaos.d1        =(ULONG) sMicros;
  539.     MyCaos.d2        =(ULONG) cSeconds;
  540.     MyCaos.d3        =(ULONG) cMicros;
  541.     MyCaos.caos_Un.Offset    =    (-102);
  542.     MyCaos.a6        =(ULONG) IntuitionBase;    
  543.     return((BOOL)PPCCallOS(&MyCaos));
  544. }
  545.  
  546. #define    DrawBorder(rp, border, leftOffset, topOffset)    _DrawBorder(INTUITION_BASE_NAME, rp, border, leftOffset, topOffset)
  547.  
  548. static __inline void
  549. _DrawBorder(void *IntuitionBase, struct RastPort *rp, struct Border *border, long leftOffset, long topOffset)
  550. {
  551. struct Caos    MyCaos;
  552.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  553. //    MyCaos.M68kStart    =    NULL;
  554. //    MyCaos.M68kSize        =    0;
  555.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  556. //    MyCaos.PPCStart        =    NULL;
  557. //    MyCaos.PPCSize        =    0;
  558.     MyCaos.a0        =(ULONG) rp;
  559.     MyCaos.a1        =(ULONG) border;
  560.     MyCaos.d0        =(ULONG) leftOffset;
  561.     MyCaos.d1        =(ULONG) topOffset;
  562.     MyCaos.caos_Un.Offset    =    (-108);
  563.     MyCaos.a6        =(ULONG) IntuitionBase;    
  564.     PPCCallOS(&MyCaos);
  565. }
  566.  
  567. #define    DrawImage(rp, image, leftOffset, topOffset)    _DrawImage(INTUITION_BASE_NAME, rp, image, leftOffset, topOffset)
  568.  
  569. static __inline void
  570. _DrawImage(void *IntuitionBase, struct RastPort *rp, struct Image *image, long leftOffset, long topOffset)
  571. {
  572. struct Caos    MyCaos;
  573.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  574. //    MyCaos.M68kStart    =    NULL;
  575. //    MyCaos.M68kSize        =    0;
  576.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  577. //    MyCaos.PPCStart        =    NULL;
  578. //    MyCaos.PPCSize        =    0;
  579.     MyCaos.a0        =(ULONG) rp;
  580.     MyCaos.a1        =(ULONG) image;
  581.     MyCaos.d0        =(ULONG) leftOffset;
  582.     MyCaos.d1        =(ULONG) topOffset;
  583.     MyCaos.caos_Un.Offset    =    (-114);
  584.     MyCaos.a6        =(ULONG) IntuitionBase;    
  585.     PPCCallOS(&MyCaos);
  586. }
  587.  
  588. #define    DrawImageState(rp, image, leftOffset, topOffset, state, drawInfo)    _DrawImageState(INTUITION_BASE_NAME, rp, image, leftOffset, topOffset, state, drawInfo)
  589.  
  590. static __inline void
  591. _DrawImageState(void *IntuitionBase, struct RastPort *rp, struct Image *image, long leftOffset, long topOffset, unsigned long state, struct DrawInfo *drawInfo)
  592. {
  593. struct Caos    MyCaos;
  594.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  595. //    MyCaos.M68kStart    =    NULL;
  596. //    MyCaos.M68kSize        =    0;
  597.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  598. //    MyCaos.PPCStart        =    NULL;
  599. //    MyCaos.PPCSize        =    0;
  600.     MyCaos.a0        =(ULONG) rp;
  601.     MyCaos.a1        =(ULONG) image;
  602.     MyCaos.d0        =(ULONG) leftOffset;
  603.     MyCaos.d1        =(ULONG) topOffset;
  604.     MyCaos.d2        =(ULONG) state;
  605.     MyCaos.a2        =(ULONG) drawInfo;
  606.     MyCaos.caos_Un.Offset    =    (-618);
  607.     MyCaos.a6        =(ULONG) IntuitionBase;    
  608.     PPCCallOS(&MyCaos);
  609. }
  610.  
  611. #define    EasyRequestArgs(window, easyStruct, idcmpPtr, args)    _EasyRequestArgs(INTUITION_BASE_NAME, window, easyStruct, idcmpPtr, args)
  612.  
  613. static __inline LONG
  614. _EasyRequestArgs(void *IntuitionBase, struct Window *window, struct EasyStruct *easyStruct, ULONG *idcmpPtr, APTR args)
  615. {
  616. struct Caos    MyCaos;
  617.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  618. //    MyCaos.M68kStart    =    NULL;
  619. //    MyCaos.M68kSize        =    0;
  620.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  621. //    MyCaos.PPCStart        =    NULL;
  622. //    MyCaos.PPCSize        =    0;
  623.     MyCaos.a0        =(ULONG) window;
  624.     MyCaos.a1        =(ULONG) easyStruct;
  625.     MyCaos.a2        =(ULONG) idcmpPtr;
  626.     MyCaos.a3        =(ULONG) args;
  627.     MyCaos.caos_Un.Offset    =    (-588);
  628.     MyCaos.a6        =(ULONG) IntuitionBase;    
  629.     return((LONG)PPCCallOS(&MyCaos));
  630. }
  631.  
  632. #ifndef NO_PPCINLINE_STDARG
  633. #define EasyRequest(a0, a1, a2, tags...) \
  634.     ({ULONG _tags[] = { tags }; EasyRequestArgs((a0), (a1), (a2), (APTR)_tags);})
  635. #endif /* !NO_PPCINLINE_STDARG */
  636.  
  637. #define    EndRefresh(window, complete)    _EndRefresh(INTUITION_BASE_NAME, window, complete)
  638.  
  639. static __inline void
  640. _EndRefresh(void *IntuitionBase, struct Window *window, long complete)
  641. {
  642. struct Caos    MyCaos;
  643.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  644. //    MyCaos.M68kStart    =    NULL;
  645. //    MyCaos.M68kSize        =    0;
  646.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  647. //    MyCaos.PPCStart        =    NULL;
  648. //    MyCaos.PPCSize        =    0;
  649.     MyCaos.a0        =(ULONG) window;
  650.     MyCaos.d0        =(ULONG) complete;
  651.     MyCaos.caos_Un.Offset    =    (-366);
  652.     MyCaos.a6        =(ULONG) IntuitionBase;    
  653.     PPCCallOS(&MyCaos);
  654. }
  655.  
  656. #define    EndRequest(requester, window)    _EndRequest(INTUITION_BASE_NAME, requester, window)
  657.  
  658. static __inline void
  659. _EndRequest(void *IntuitionBase, struct Requester *requester, struct Window *window)
  660. {
  661. struct Caos    MyCaos;
  662.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  663. //    MyCaos.M68kStart    =    NULL;
  664. //    MyCaos.M68kSize        =    0;
  665.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  666. //    MyCaos.PPCStart        =    NULL;
  667. //    MyCaos.PPCSize        =    0;
  668.     MyCaos.a0        =(ULONG) requester;
  669.     MyCaos.a1        =(ULONG) window;
  670.     MyCaos.caos_Un.Offset    =    (-120);
  671.     MyCaos.a6        =(ULONG) IntuitionBase;    
  672.     PPCCallOS(&MyCaos);
  673. }
  674.  
  675. #define    EraseImage(rp, image, leftOffset, topOffset)    _EraseImage(INTUITION_BASE_NAME, rp, image, leftOffset, topOffset)
  676.  
  677. static __inline void
  678. _EraseImage(void *IntuitionBase, struct RastPort *rp, struct Image *image, long leftOffset, long topOffset)
  679. {
  680. struct Caos    MyCaos;
  681.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  682. //    MyCaos.M68kStart    =    NULL;
  683. //    MyCaos.M68kSize        =    0;
  684.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  685. //    MyCaos.PPCStart        =    NULL;
  686. //    MyCaos.PPCSize        =    0;
  687.     MyCaos.a0        =(ULONG) rp;
  688.     MyCaos.a1        =(ULONG) image;
  689.     MyCaos.d0        =(ULONG) leftOffset;
  690.     MyCaos.d1        =(ULONG) topOffset;
  691.     MyCaos.caos_Un.Offset    =    (-630);
  692.     MyCaos.a6        =(ULONG) IntuitionBase;    
  693.     PPCCallOS(&MyCaos);
  694. }
  695.  
  696. #define    FreeClass(classPtr)    _FreeClass(INTUITION_BASE_NAME, classPtr)
  697.  
  698. static __inline BOOL
  699. _FreeClass(void *IntuitionBase, struct IClass *classPtr)
  700. {
  701. struct Caos    MyCaos;
  702.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  703. //    MyCaos.M68kStart    =    NULL;
  704. //    MyCaos.M68kSize        =    0;
  705.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  706. //    MyCaos.PPCStart        =    NULL;
  707. //    MyCaos.PPCSize        =    0;
  708.     MyCaos.a0        =(ULONG) classPtr;
  709.     MyCaos.caos_Un.Offset    =    (-714);
  710.     MyCaos.a6        =(ULONG) IntuitionBase;    
  711.     return((BOOL)PPCCallOS(&MyCaos));
  712. }
  713.  
  714. #define    FreeRemember(rememberKey, reallyForget)    _FreeRemember(INTUITION_BASE_NAME, rememberKey, reallyForget)
  715.  
  716. static __inline void
  717. _FreeRemember(void *IntuitionBase, struct Remember **rememberKey, long reallyForget)
  718. {
  719. struct Caos    MyCaos;
  720.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  721. //    MyCaos.M68kStart    =    NULL;
  722. //    MyCaos.M68kSize        =    0;
  723.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  724. //    MyCaos.PPCStart        =    NULL;
  725. //    MyCaos.PPCSize        =    0;
  726.     MyCaos.a0        =(ULONG) rememberKey;
  727.     MyCaos.d0        =(ULONG) reallyForget;
  728.     MyCaos.caos_Un.Offset    =    (-408);
  729.     MyCaos.a6        =(ULONG) IntuitionBase;    
  730.     PPCCallOS(&MyCaos);
  731. }
  732.  
  733. #define    FreeScreenBuffer(sc, sb)    _FreeScreenBuffer(INTUITION_BASE_NAME, sc, sb)
  734.  
  735. static __inline void
  736. _FreeScreenBuffer(void *IntuitionBase, struct Screen *sc, struct ScreenBuffer *sb)
  737. {
  738. struct Caos    MyCaos;
  739.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  740. //    MyCaos.M68kStart    =    NULL;
  741. //    MyCaos.M68kSize        =    0;
  742.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  743. //    MyCaos.PPCStart        =    NULL;
  744. //    MyCaos.PPCSize        =    0;
  745.     MyCaos.a0        =(ULONG) sc;
  746.     MyCaos.a1        =(ULONG) sb;
  747.     MyCaos.caos_Un.Offset    =    (-774);
  748.     MyCaos.a6        =(ULONG) IntuitionBase;    
  749.     PPCCallOS(&MyCaos);
  750. }
  751.  
  752. #define    FreeScreenDrawInfo(screen, drawInfo)    _FreeScreenDrawInfo(INTUITION_BASE_NAME, screen, drawInfo)
  753.  
  754. static __inline void
  755. _FreeScreenDrawInfo(void *IntuitionBase, struct Screen *screen, struct DrawInfo *drawInfo)
  756. {
  757. struct Caos    MyCaos;
  758.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  759. //    MyCaos.M68kStart    =    NULL;
  760. //    MyCaos.M68kSize        =    0;
  761.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  762. //    MyCaos.PPCStart        =    NULL;
  763. //    MyCaos.PPCSize        =    0;
  764.     MyCaos.a0        =(ULONG) screen;
  765.     MyCaos.a1        =(ULONG) drawInfo;
  766.     MyCaos.caos_Un.Offset    =    (-696);
  767.     MyCaos.a6        =(ULONG) IntuitionBase;    
  768.     PPCCallOS(&MyCaos);
  769. }
  770.  
  771. #define    FreeSysRequest(window)    _FreeSysRequest(INTUITION_BASE_NAME, window)
  772.  
  773. static __inline void
  774. _FreeSysRequest(void *IntuitionBase, struct Window *window)
  775. {
  776. struct Caos    MyCaos;
  777.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  778. //    MyCaos.M68kStart    =    NULL;
  779. //    MyCaos.M68kSize        =    0;
  780.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  781. //    MyCaos.PPCStart        =    NULL;
  782. //    MyCaos.PPCSize        =    0;
  783.     MyCaos.a0        =(ULONG) window;
  784.     MyCaos.caos_Un.Offset    =    (-372);
  785.     MyCaos.a6        =(ULONG) IntuitionBase;    
  786.     PPCCallOS(&MyCaos);
  787. }
  788.  
  789. #define    GadgetMouse(gadget, gInfo, mousePoint)    _GadgetMouse(INTUITION_BASE_NAME, gadget, gInfo, mousePoint)
  790.  
  791. static __inline void
  792. _GadgetMouse(void *IntuitionBase, struct Gadget *gadget, struct GadgetInfo *gInfo, WORD *mousePoint)
  793. {
  794. struct Caos    MyCaos;
  795.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  796. //    MyCaos.M68kStart    =    NULL;
  797. //    MyCaos.M68kSize        =    0;
  798.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  799. //    MyCaos.PPCStart        =    NULL;
  800. //    MyCaos.PPCSize        =    0;
  801.     MyCaos.a0        =(ULONG) gadget;
  802.     MyCaos.a1        =(ULONG) gInfo;
  803.     MyCaos.a2        =(ULONG) mousePoint;
  804.     MyCaos.caos_Un.Offset    =    (-570);
  805.     MyCaos.a6        =(ULONG) IntuitionBase;    
  806.     PPCCallOS(&MyCaos);
  807. }
  808.  
  809. #define    GetAttr(attrID, object, storagePtr)    _GetAttr(INTUITION_BASE_NAME, attrID, object, storagePtr)
  810.  
  811. static __inline ULONG
  812. _GetAttr(void *IntuitionBase, unsigned long attrID, APTR object, ULONG *storagePtr)
  813. {
  814. struct Caos    MyCaos;
  815.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  816. //    MyCaos.M68kStart    =    NULL;
  817. //    MyCaos.M68kSize        =    0;
  818.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  819. //    MyCaos.PPCStart        =    NULL;
  820. //    MyCaos.PPCSize        =    0;
  821.     MyCaos.d0        =(ULONG) attrID;
  822.     MyCaos.a0        =(ULONG) object;
  823.     MyCaos.a1        =(ULONG) storagePtr;
  824.     MyCaos.caos_Un.Offset    =    (-654);
  825.     MyCaos.a6        =(ULONG) IntuitionBase;    
  826.     return((ULONG)PPCCallOS(&MyCaos));
  827. }
  828.  
  829. #define    GetDefPrefs(preferences, size)    _GetDefPrefs(INTUITION_BASE_NAME, preferences, size)
  830.  
  831. static __inline struct Preferences *
  832. _GetDefPrefs(void *IntuitionBase, struct Preferences *preferences, long size)
  833. {
  834. struct Caos    MyCaos;
  835.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  836. //    MyCaos.M68kStart    =    NULL;
  837. //    MyCaos.M68kSize        =    0;
  838.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  839. //    MyCaos.PPCStart        =    NULL;
  840. //    MyCaos.PPCSize        =    0;
  841.     MyCaos.a0        =(ULONG) preferences;
  842.     MyCaos.d0        =(ULONG) size;
  843.     MyCaos.caos_Un.Offset    =    (-126);
  844.     MyCaos.a6        =(ULONG) IntuitionBase;    
  845.     return((struct Preferences *)PPCCallOS(&MyCaos));
  846. }
  847.  
  848. #define    GetDefaultPubScreen(nameBuffer)    _GetDefaultPubScreen(INTUITION_BASE_NAME, nameBuffer)
  849.  
  850. static __inline void
  851. _GetDefaultPubScreen(void *IntuitionBase, UBYTE *nameBuffer)
  852. {
  853. struct Caos    MyCaos;
  854.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  855. //    MyCaos.M68kStart    =    NULL;
  856. //    MyCaos.M68kSize        =    0;
  857.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  858. //    MyCaos.PPCStart        =    NULL;
  859. //    MyCaos.PPCSize        =    0;
  860.     MyCaos.a0        =(ULONG) nameBuffer;
  861.     MyCaos.caos_Un.Offset    =    (-582);
  862.     MyCaos.a6        =(ULONG) IntuitionBase;    
  863.     PPCCallOS(&MyCaos);
  864. }
  865.  
  866. #define    GetPrefs(preferences, size)    _GetPrefs(INTUITION_BASE_NAME, preferences, size)
  867.  
  868. static __inline struct Preferences *
  869. _GetPrefs(void *IntuitionBase, struct Preferences *preferences, long size)
  870. {
  871. struct Caos    MyCaos;
  872.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  873. //    MyCaos.M68kStart    =    NULL;
  874. //    MyCaos.M68kSize        =    0;
  875.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  876. //    MyCaos.PPCStart        =    NULL;
  877. //    MyCaos.PPCSize        =    0;
  878.     MyCaos.a0        =(ULONG) preferences;
  879.     MyCaos.d0        =(ULONG) size;
  880.     MyCaos.caos_Un.Offset    =    (-132);
  881.     MyCaos.a6        =(ULONG) IntuitionBase;    
  882.     return((struct Preferences *)PPCCallOS(&MyCaos));
  883. }
  884.  
  885. #define    GetScreenData(buffer, size, type, screen)    _GetScreenData(INTUITION_BASE_NAME, buffer, size, type, screen)
  886.  
  887. static __inline LONG
  888. _GetScreenData(void *IntuitionBase, APTR buffer, unsigned long size, unsigned long type, struct Screen *screen)
  889. {
  890. struct Caos    MyCaos;
  891.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  892. //    MyCaos.M68kStart    =    NULL;
  893. //    MyCaos.M68kSize        =    0;
  894.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  895. //    MyCaos.PPCStart        =    NULL;
  896. //    MyCaos.PPCSize        =    0;
  897.     MyCaos.a0        =(ULONG) buffer;
  898.     MyCaos.d0        =(ULONG) size;
  899.     MyCaos.d1        =(ULONG) type;
  900.     MyCaos.a1        =(ULONG) screen;
  901.     MyCaos.caos_Un.Offset    =    (-426);
  902.     MyCaos.a6        =(ULONG) IntuitionBase;    
  903.     return((LONG)PPCCallOS(&MyCaos));
  904. }
  905.  
  906. #define    GetScreenDrawInfo(screen)    _GetScreenDrawInfo(INTUITION_BASE_NAME, screen)
  907.  
  908. static __inline struct DrawInfo *
  909. _GetScreenDrawInfo(void *IntuitionBase, struct Screen *screen)
  910. {
  911. struct Caos    MyCaos;
  912.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  913. //    MyCaos.M68kStart    =    NULL;
  914. //    MyCaos.M68kSize        =    0;
  915.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  916. //    MyCaos.PPCStart        =    NULL;
  917. //    MyCaos.PPCSize        =    0;
  918.     MyCaos.a0        =(ULONG) screen;
  919.     MyCaos.caos_Un.Offset    =    (-690);
  920.     MyCaos.a6        =(ULONG) IntuitionBase;    
  921.     return((struct DrawInfo *)PPCCallOS(&MyCaos));
  922. }
  923.  
  924. #define    HelpControl(win, flags)    _HelpControl(INTUITION_BASE_NAME, win, flags)
  925.  
  926. static __inline void
  927. _HelpControl(void *IntuitionBase, struct Window *win, unsigned long flags)
  928. {
  929. struct Caos    MyCaos;
  930.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  931. //    MyCaos.M68kStart    =    NULL;
  932. //    MyCaos.M68kSize        =    0;
  933.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  934. //    MyCaos.PPCStart        =    NULL;
  935. //    MyCaos.PPCSize        =    0;
  936.     MyCaos.a0        =(ULONG) win;
  937.     MyCaos.d0        =(ULONG) flags;
  938.     MyCaos.caos_Un.Offset    =    (-828);
  939.     MyCaos.a6        =(ULONG) IntuitionBase;    
  940.     PPCCallOS(&MyCaos);
  941. }
  942.  
  943. #define    InitRequester(requester)    _InitRequester(INTUITION_BASE_NAME, requester)
  944.  
  945. static __inline void
  946. _InitRequester(void *IntuitionBase, struct Requester *requester)
  947. {
  948. struct Caos    MyCaos;
  949.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  950. //    MyCaos.M68kStart    =    NULL;
  951. //    MyCaos.M68kSize        =    0;
  952.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  953. //    MyCaos.PPCStart        =    NULL;
  954. //    MyCaos.PPCSize        =    0;
  955.     MyCaos.a0        =(ULONG) requester;
  956.     MyCaos.caos_Un.Offset    =    (-138);
  957.     MyCaos.a6        =(ULONG) IntuitionBase;    
  958.     PPCCallOS(&MyCaos);
  959. }
  960.  
  961. #define    IntuiTextLength(iText)    _IntuiTextLength(INTUITION_BASE_NAME, iText)
  962.  
  963. static __inline LONG
  964. _IntuiTextLength(void *IntuitionBase, struct IntuiText *iText)
  965. {
  966. struct Caos    MyCaos;
  967.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  968. //    MyCaos.M68kStart    =    NULL;
  969. //    MyCaos.M68kSize        =    0;
  970.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  971. //    MyCaos.PPCStart        =    NULL;
  972. //    MyCaos.PPCSize        =    0;
  973.     MyCaos.a0        =(ULONG) iText;
  974.     MyCaos.caos_Un.Offset    =    (-330);
  975.     MyCaos.a6        =(ULONG) IntuitionBase;    
  976.     return((LONG)PPCCallOS(&MyCaos));
  977. }
  978.  
  979. #define    Intuition(iEvent)    _Intuition(INTUITION_BASE_NAME, iEvent)
  980.  
  981. static __inline void
  982. _Intuition(void *IntuitionBase, struct InputEvent *iEvent)
  983. {
  984. struct Caos    MyCaos;
  985.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  986. //    MyCaos.M68kStart    =    NULL;
  987. //    MyCaos.M68kSize        =    0;
  988.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  989. //    MyCaos.PPCStart        =    NULL;
  990. //    MyCaos.PPCSize        =    0;
  991.     MyCaos.a0        =(ULONG) iEvent;
  992.     MyCaos.caos_Un.Offset    =    (-36);
  993.     MyCaos.a6        =(ULONG) IntuitionBase;    
  994.     PPCCallOS(&MyCaos);
  995. }
  996.  
  997. #define    ItemAddress(menuStrip, menuNumber)    _ItemAddress(INTUITION_BASE_NAME, menuStrip, menuNumber)
  998.  
  999. static __inline struct MenuItem *
  1000. _ItemAddress(void *IntuitionBase, struct Menu *menuStrip, unsigned long menuNumber)
  1001. {
  1002. struct Caos    MyCaos;
  1003.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1004. //    MyCaos.M68kStart    =    NULL;
  1005. //    MyCaos.M68kSize        =    0;
  1006.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1007. //    MyCaos.PPCStart        =    NULL;
  1008. //    MyCaos.PPCSize        =    0;
  1009.     MyCaos.a0        =(ULONG) menuStrip;
  1010.     MyCaos.d0        =(ULONG) menuNumber;
  1011.     MyCaos.caos_Un.Offset    =    (-144);
  1012.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1013.     return((struct MenuItem *)PPCCallOS(&MyCaos));
  1014. }
  1015.  
  1016. #define    LendMenus(fromwindow, towindow)    _LendMenus(INTUITION_BASE_NAME, fromwindow, towindow)
  1017.  
  1018. static __inline void
  1019. _LendMenus(void *IntuitionBase, struct Window *fromwindow, struct Window *towindow)
  1020. {
  1021. struct Caos    MyCaos;
  1022.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1023. //    MyCaos.M68kStart    =    NULL;
  1024. //    MyCaos.M68kSize        =    0;
  1025.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1026. //    MyCaos.PPCStart        =    NULL;
  1027. //    MyCaos.PPCSize        =    0;
  1028.     MyCaos.a0        =(ULONG) fromwindow;
  1029.     MyCaos.a1        =(ULONG) towindow;
  1030.     MyCaos.caos_Un.Offset    =    (-804);
  1031.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1032.     PPCCallOS(&MyCaos);
  1033. }
  1034.  
  1035. #define    LockIBase(dontknow)    _LockIBase(INTUITION_BASE_NAME, dontknow)
  1036.  
  1037. static __inline ULONG
  1038. _LockIBase(void *IntuitionBase, unsigned long dontknow)
  1039. {
  1040. struct Caos    MyCaos;
  1041.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1042. //    MyCaos.M68kStart    =    NULL;
  1043. //    MyCaos.M68kSize        =    0;
  1044.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1045. //    MyCaos.PPCStart        =    NULL;
  1046. //    MyCaos.PPCSize        =    0;
  1047.     MyCaos.d0        =(ULONG) dontknow;
  1048.     MyCaos.caos_Un.Offset    =    (-414);
  1049.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1050.     return((ULONG)PPCCallOS(&MyCaos));
  1051. }
  1052.  
  1053. #define    LockPubScreen(name)    _LockPubScreen(INTUITION_BASE_NAME, name)
  1054.  
  1055. static __inline struct Screen *
  1056. _LockPubScreen(void *IntuitionBase, UBYTE *name)
  1057. {
  1058. struct Caos    MyCaos;
  1059.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1060. //    MyCaos.M68kStart    =    NULL;
  1061. //    MyCaos.M68kSize        =    0;
  1062.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1063. //    MyCaos.PPCStart        =    NULL;
  1064. //    MyCaos.PPCSize        =    0;
  1065.     MyCaos.a0        =(ULONG) name;
  1066.     MyCaos.caos_Un.Offset    =    (-510);
  1067.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1068.     return((struct Screen *)PPCCallOS(&MyCaos));
  1069. }
  1070.  
  1071. #define    LockPubScreenList()    _LockPubScreenList(INTUITION_BASE_NAME)
  1072.  
  1073. static __inline struct List *
  1074. _LockPubScreenList(void *IntuitionBase)
  1075. {
  1076. struct Caos    MyCaos;
  1077.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1078. //    MyCaos.M68kStart    =    NULL;
  1079. //    MyCaos.M68kSize        =    0;
  1080.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1081. //    MyCaos.PPCStart        =    NULL;
  1082. //    MyCaos.PPCSize        =    0;
  1083.     MyCaos.caos_Un.Offset    =    (-522);
  1084.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1085.     return((struct List *)PPCCallOS(&MyCaos));
  1086. }
  1087.  
  1088. #define    MakeClass(classID, superClassID, superClassPtr, instanceSize, flags)    _MakeClass(INTUITION_BASE_NAME, classID, superClassID, superClassPtr, instanceSize, flags)
  1089.  
  1090. static __inline struct IClass *
  1091. _MakeClass(void *IntuitionBase, UBYTE *classID, UBYTE *superClassID, struct IClass *superClassPtr, unsigned long instanceSize, unsigned long flags)
  1092. {
  1093. struct Caos    MyCaos;
  1094.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1095. //    MyCaos.M68kStart    =    NULL;
  1096. //    MyCaos.M68kSize        =    0;
  1097.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1098. //    MyCaos.PPCStart        =    NULL;
  1099. //    MyCaos.PPCSize        =    0;
  1100.     MyCaos.a0        =(ULONG) classID;
  1101.     MyCaos.a1        =(ULONG) superClassID;
  1102.     MyCaos.a2        =(ULONG) superClassPtr;
  1103.     MyCaos.d0        =(ULONG) instanceSize;
  1104.     MyCaos.d1        =(ULONG) flags;
  1105.     MyCaos.caos_Un.Offset    =    (-678);
  1106.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1107.     return((struct IClass *)PPCCallOS(&MyCaos));
  1108. }
  1109.  
  1110. #define    MakeScreen(screen)    _MakeScreen(INTUITION_BASE_NAME, screen)
  1111.  
  1112. static __inline LONG
  1113. _MakeScreen(void *IntuitionBase, struct Screen *screen)
  1114. {
  1115. struct Caos    MyCaos;
  1116.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1117. //    MyCaos.M68kStart    =    NULL;
  1118. //    MyCaos.M68kSize        =    0;
  1119.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1120. //    MyCaos.PPCStart        =    NULL;
  1121. //    MyCaos.PPCSize        =    0;
  1122.     MyCaos.a0        =(ULONG) screen;
  1123.     MyCaos.caos_Un.Offset    =    (-378);
  1124.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1125.     return((LONG)PPCCallOS(&MyCaos));
  1126. }
  1127.  
  1128. #define    ModifyIDCMP(window, flags)    _ModifyIDCMP(INTUITION_BASE_NAME, window, flags)
  1129.  
  1130. static __inline BOOL
  1131. _ModifyIDCMP(void *IntuitionBase, struct Window *window, unsigned long flags)
  1132. {
  1133. struct Caos    MyCaos;
  1134.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1135. //    MyCaos.M68kStart    =    NULL;
  1136. //    MyCaos.M68kSize        =    0;
  1137.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1138. //    MyCaos.PPCStart        =    NULL;
  1139. //    MyCaos.PPCSize        =    0;
  1140.     MyCaos.a0        =(ULONG) window;
  1141.     MyCaos.d0        =(ULONG) flags;
  1142.     MyCaos.caos_Un.Offset    =    (-150);
  1143.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1144.     return((BOOL)PPCCallOS(&MyCaos));
  1145. }
  1146.  
  1147. #define    ModifyProp(gadget, window, requester, flags, horizPot, vertPot, horizBody, vertBody)    _ModifyProp(INTUITION_BASE_NAME, gadget, window, requester, flags, horizPot, vertPot, horizBody, vertBody)
  1148.  
  1149. static __inline void
  1150. _ModifyProp(void *IntuitionBase, struct Gadget *gadget, struct Window *window, struct Requester *requester, unsigned long flags, unsigned long horizPot, unsigned long vertPot, unsigned long horizBody, unsigned long vertBody)
  1151. {
  1152. struct Caos    MyCaos;
  1153.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1154. //    MyCaos.M68kStart    =    NULL;
  1155. //    MyCaos.M68kSize        =    0;
  1156.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1157. //    MyCaos.PPCStart        =    NULL;
  1158. //    MyCaos.PPCSize        =    0;
  1159.     MyCaos.a0        =(ULONG) gadget;
  1160.     MyCaos.a1        =(ULONG) window;
  1161.     MyCaos.a2        =(ULONG) requester;
  1162.     MyCaos.d0        =(ULONG) flags;
  1163.     MyCaos.d1        =(ULONG) horizPot;
  1164.     MyCaos.d2        =(ULONG) vertPot;
  1165.     MyCaos.d3        =(ULONG) horizBody;
  1166.     MyCaos.d4        =(ULONG) vertBody;
  1167.     MyCaos.caos_Un.Offset    =    (-156);
  1168.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1169.     PPCCallOS(&MyCaos);
  1170. }
  1171.  
  1172. #define    MoveScreen(screen, dx, dy)    _MoveScreen(INTUITION_BASE_NAME, screen, dx, dy)
  1173.  
  1174. static __inline void
  1175. _MoveScreen(void *IntuitionBase, struct Screen *screen, long dx, long dy)
  1176. {
  1177. struct Caos    MyCaos;
  1178.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1179. //    MyCaos.M68kStart    =    NULL;
  1180. //    MyCaos.M68kSize        =    0;
  1181.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1182. //    MyCaos.PPCStart        =    NULL;
  1183. //    MyCaos.PPCSize        =    0;
  1184.     MyCaos.a0        =(ULONG) screen;
  1185.     MyCaos.d0        =(ULONG) dx;
  1186.     MyCaos.d1        =(ULONG) dy;
  1187.     MyCaos.caos_Un.Offset    =    (-162);
  1188.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1189.     PPCCallOS(&MyCaos);
  1190. }
  1191.  
  1192. #define    MoveWindow(window, dx, dy)    _MoveWindow(INTUITION_BASE_NAME, window, dx, dy)
  1193.  
  1194. static __inline void
  1195. _MoveWindow(void *IntuitionBase, struct Window *window, long dx, long dy)
  1196. {
  1197. struct Caos    MyCaos;
  1198.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1199. //    MyCaos.M68kStart    =    NULL;
  1200. //    MyCaos.M68kSize        =    0;
  1201.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1202. //    MyCaos.PPCStart        =    NULL;
  1203. //    MyCaos.PPCSize        =    0;
  1204.     MyCaos.a0        =(ULONG) window;
  1205.     MyCaos.d0        =(ULONG) dx;
  1206.     MyCaos.d1        =(ULONG) dy;
  1207.     MyCaos.caos_Un.Offset    =    (-168);
  1208.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1209.     PPCCallOS(&MyCaos);
  1210. }
  1211.  
  1212. #define    MoveWindowInFrontOf(window, behindWindow)    _MoveWindowInFrontOf(INTUITION_BASE_NAME, window, behindWindow)
  1213.  
  1214. static __inline void
  1215. _MoveWindowInFrontOf(void *IntuitionBase, struct Window *window, struct Window *behindWindow)
  1216. {
  1217. struct Caos    MyCaos;
  1218.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1219. //    MyCaos.M68kStart    =    NULL;
  1220. //    MyCaos.M68kSize        =    0;
  1221.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1222. //    MyCaos.PPCStart        =    NULL;
  1223. //    MyCaos.PPCSize        =    0;
  1224.     MyCaos.a0        =(ULONG) window;
  1225.     MyCaos.a1        =(ULONG) behindWindow;
  1226.     MyCaos.caos_Un.Offset    =    (-480);
  1227.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1228.     PPCCallOS(&MyCaos);
  1229. }
  1230.  
  1231. #define    NewModifyProp(gadget, window, requester, flags, horizPot, vertPot, horizBody, vertBody, numGad)    _NewModifyProp(INTUITION_BASE_NAME, gadget, window, requester, flags, horizPot, vertPot, horizBody, vertBody, numGad)
  1232.  
  1233. static __inline void
  1234. _NewModifyProp(void *IntuitionBase, struct Gadget *gadget, struct Window *window, struct Requester *requester, unsigned long flags, unsigned long horizPot, unsigned long vertPot, unsigned long horizBody, unsigned long vertBody, long numGad)
  1235. {
  1236. struct Caos    MyCaos;
  1237.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1238. //    MyCaos.M68kStart    =    NULL;
  1239. //    MyCaos.M68kSize        =    0;
  1240.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1241. //    MyCaos.PPCStart        =    NULL;
  1242. //    MyCaos.PPCSize        =    0;
  1243.     MyCaos.a0        =(ULONG) gadget;
  1244.     MyCaos.a1        =(ULONG) window;
  1245.     MyCaos.a2        =(ULONG) requester;
  1246.     MyCaos.d0        =(ULONG) flags;
  1247.     MyCaos.d1        =(ULONG) horizPot;
  1248.     MyCaos.d2        =(ULONG) vertPot;
  1249.     MyCaos.d3        =(ULONG) horizBody;
  1250.     MyCaos.d4        =(ULONG) vertBody;
  1251.     MyCaos.d5        =(ULONG) numGad;
  1252.     MyCaos.caos_Un.Offset    =    (-468);
  1253.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1254.     PPCCallOS(&MyCaos);
  1255. }
  1256.  
  1257. #define    NewObjectA(classPtr, classID, tagList)    _NewObjectA(INTUITION_BASE_NAME, classPtr, classID, tagList)
  1258.  
  1259. static __inline APTR
  1260. _NewObjectA(void *IntuitionBase, struct IClass *classPtr, UBYTE *classID, struct TagItem *tagList)
  1261. {
  1262. struct Caos    MyCaos;
  1263.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1264. //    MyCaos.M68kStart    =    NULL;
  1265. //    MyCaos.M68kSize        =    0;
  1266.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1267. //    MyCaos.PPCStart        =    NULL;
  1268. //    MyCaos.PPCSize        =    0;
  1269.     MyCaos.a0        =(ULONG) classPtr;
  1270.     MyCaos.a1        =(ULONG) classID;
  1271.     MyCaos.a2        =(ULONG) tagList;
  1272.     MyCaos.caos_Un.Offset    =    (-636);
  1273.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1274.     return((APTR)PPCCallOS(&MyCaos));
  1275. }
  1276.  
  1277. #ifndef NO_PPCINLINE_STDARG
  1278. #define NewObject(a0, a1, tags...) \
  1279.     ({ULONG _tags[] = { tags }; NewObjectA((a0), (a1), (struct TagItem *)_tags);})
  1280. #endif /* !NO_PPCINLINE_STDARG */
  1281.  
  1282. #define    NextObject(objectPtrPtr)    _NextObject(INTUITION_BASE_NAME, objectPtrPtr)
  1283.  
  1284. static __inline APTR
  1285. _NextObject(void *IntuitionBase, APTR objectPtrPtr)
  1286. {
  1287. struct Caos    MyCaos;
  1288.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1289. //    MyCaos.M68kStart    =    NULL;
  1290. //    MyCaos.M68kSize        =    0;
  1291.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1292. //    MyCaos.PPCStart        =    NULL;
  1293. //    MyCaos.PPCSize        =    0;
  1294.     MyCaos.a0        =(ULONG) objectPtrPtr;
  1295.     MyCaos.caos_Un.Offset    =    (-666);
  1296.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1297.     return((APTR)PPCCallOS(&MyCaos));
  1298. }
  1299.  
  1300. #define    NextPubScreen(screen, namebuf)    _NextPubScreen(INTUITION_BASE_NAME, screen, namebuf)
  1301.  
  1302. static __inline UBYTE *
  1303. _NextPubScreen(void *IntuitionBase, struct Screen *screen, UBYTE *namebuf)
  1304. {
  1305. struct Caos    MyCaos;
  1306.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1307. //    MyCaos.M68kStart    =    NULL;
  1308. //    MyCaos.M68kSize        =    0;
  1309.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1310. //    MyCaos.PPCStart        =    NULL;
  1311. //    MyCaos.PPCSize        =    0;
  1312.     MyCaos.a0        =(ULONG) screen;
  1313.     MyCaos.a1        =(ULONG) namebuf;
  1314.     MyCaos.caos_Un.Offset    =    (-534);
  1315.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1316.     return((UBYTE *)PPCCallOS(&MyCaos));
  1317. }
  1318.  
  1319. #define    ObtainGIRPort(gInfo)    _ObtainGIRPort(INTUITION_BASE_NAME, gInfo)
  1320.  
  1321. static __inline struct RastPort *
  1322. _ObtainGIRPort(void *IntuitionBase, struct GadgetInfo *gInfo)
  1323. {
  1324. struct Caos    MyCaos;
  1325.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1326. //    MyCaos.M68kStart    =    NULL;
  1327. //    MyCaos.M68kSize        =    0;
  1328.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1329. //    MyCaos.PPCStart        =    NULL;
  1330. //    MyCaos.PPCSize        =    0;
  1331.     MyCaos.a0        =(ULONG) gInfo;
  1332.     MyCaos.caos_Un.Offset    =    (-558);
  1333.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1334.     return((struct RastPort *)PPCCallOS(&MyCaos));
  1335. }
  1336.  
  1337. #define    OffGadget(gadget, window, requester)    _OffGadget(INTUITION_BASE_NAME, gadget, window, requester)
  1338.  
  1339. static __inline void
  1340. _OffGadget(void *IntuitionBase, struct Gadget *gadget, struct Window *window, struct Requester *requester)
  1341. {
  1342. struct Caos    MyCaos;
  1343.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1344. //    MyCaos.M68kStart    =    NULL;
  1345. //    MyCaos.M68kSize        =    0;
  1346.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1347. //    MyCaos.PPCStart        =    NULL;
  1348. //    MyCaos.PPCSize        =    0;
  1349.     MyCaos.a0        =(ULONG) gadget;
  1350.     MyCaos.a1        =(ULONG) window;
  1351.     MyCaos.a2        =(ULONG) requester;
  1352.     MyCaos.caos_Un.Offset    =    (-174);
  1353.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1354.     PPCCallOS(&MyCaos);
  1355. }
  1356.  
  1357. #define    OffMenu(window, menuNumber)    _OffMenu(INTUITION_BASE_NAME, window, menuNumber)
  1358.  
  1359. static __inline void
  1360. _OffMenu(void *IntuitionBase, struct Window *window, unsigned long menuNumber)
  1361. {
  1362. struct Caos    MyCaos;
  1363.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1364. //    MyCaos.M68kStart    =    NULL;
  1365. //    MyCaos.M68kSize        =    0;
  1366.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1367. //    MyCaos.PPCStart        =    NULL;
  1368. //    MyCaos.PPCSize        =    0;
  1369.     MyCaos.a0        =(ULONG) window;
  1370.     MyCaos.d0        =(ULONG) menuNumber;
  1371.     MyCaos.caos_Un.Offset    =    (-180);
  1372.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1373.     PPCCallOS(&MyCaos);
  1374. }
  1375.  
  1376. #define    OnGadget(gadget, window, requester)    _OnGadget(INTUITION_BASE_NAME, gadget, window, requester)
  1377.  
  1378. static __inline void
  1379. _OnGadget(void *IntuitionBase, struct Gadget *gadget, struct Window *window, struct Requester *requester)
  1380. {
  1381. struct Caos    MyCaos;
  1382.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1383. //    MyCaos.M68kStart    =    NULL;
  1384. //    MyCaos.M68kSize        =    0;
  1385.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1386. //    MyCaos.PPCStart        =    NULL;
  1387. //    MyCaos.PPCSize        =    0;
  1388.     MyCaos.a0        =(ULONG) gadget;
  1389.     MyCaos.a1        =(ULONG) window;
  1390.     MyCaos.a2        =(ULONG) requester;
  1391.     MyCaos.caos_Un.Offset    =    (-186);
  1392.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1393.     PPCCallOS(&MyCaos);
  1394. }
  1395.  
  1396. #define    OnMenu(window, menuNumber)    _OnMenu(INTUITION_BASE_NAME, window, menuNumber)
  1397.  
  1398. static __inline void
  1399. _OnMenu(void *IntuitionBase, struct Window *window, unsigned long menuNumber)
  1400. {
  1401. struct Caos    MyCaos;
  1402.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1403. //    MyCaos.M68kStart    =    NULL;
  1404. //    MyCaos.M68kSize        =    0;
  1405.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1406. //    MyCaos.PPCStart        =    NULL;
  1407. //    MyCaos.PPCSize        =    0;
  1408.     MyCaos.a0        =(ULONG) window;
  1409.     MyCaos.d0        =(ULONG) menuNumber;
  1410.     MyCaos.caos_Un.Offset    =    (-192);
  1411.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1412.     PPCCallOS(&MyCaos);
  1413. }
  1414.  
  1415. #define    OpenIntuition()    _OpenIntuition(INTUITION_BASE_NAME)
  1416.  
  1417. static __inline void
  1418. _OpenIntuition(void *IntuitionBase)
  1419. {
  1420. struct Caos    MyCaos;
  1421.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1422. //    MyCaos.M68kStart    =    NULL;
  1423. //    MyCaos.M68kSize        =    0;
  1424.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1425. //    MyCaos.PPCStart        =    NULL;
  1426. //    MyCaos.PPCSize        =    0;
  1427.     MyCaos.caos_Un.Offset    =    (-30);
  1428.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1429.     PPCCallOS(&MyCaos);
  1430. }
  1431.  
  1432. #define    OpenScreen(newScreen)    _OpenScreen(INTUITION_BASE_NAME, newScreen)
  1433.  
  1434. static __inline struct Screen *
  1435. _OpenScreen(void *IntuitionBase, struct NewScreen *newScreen)
  1436. {
  1437. struct Caos    MyCaos;
  1438.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1439. //    MyCaos.M68kStart    =    NULL;
  1440. //    MyCaos.M68kSize        =    0;
  1441.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1442. //    MyCaos.PPCStart        =    NULL;
  1443. //    MyCaos.PPCSize        =    0;
  1444.     MyCaos.a0        =(ULONG) newScreen;
  1445.     MyCaos.caos_Un.Offset    =    (-198);
  1446.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1447.     return((struct Screen *)PPCCallOS(&MyCaos));
  1448. }
  1449.  
  1450. #define    OpenScreenTagList(newScreen, tagList)    _OpenScreenTagList(INTUITION_BASE_NAME, newScreen, tagList)
  1451.  
  1452. static __inline struct Screen *
  1453. _OpenScreenTagList(void *IntuitionBase, struct NewScreen *newScreen, struct TagItem *tagList)
  1454. {
  1455. struct Caos    MyCaos;
  1456.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1457. //    MyCaos.M68kStart    =    NULL;
  1458. //    MyCaos.M68kSize        =    0;
  1459.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1460. //    MyCaos.PPCStart        =    NULL;
  1461. //    MyCaos.PPCSize        =    0;
  1462.     MyCaos.a0        =(ULONG) newScreen;
  1463.     MyCaos.a1        =(ULONG) tagList;
  1464.     MyCaos.caos_Un.Offset    =    (-612);
  1465.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1466.     return((struct Screen *)PPCCallOS(&MyCaos));
  1467. }
  1468.  
  1469. #ifndef NO_PPCINLINE_STDARG
  1470. #define OpenScreenTags(a0, tags...) \
  1471.     ({ULONG _tags[] = { tags }; OpenScreenTagList((a0), (struct TagItem *)_tags);})
  1472. #endif /* !NO_PPCINLINE_STDARG */
  1473.  
  1474. #define    OpenWindow(newWindow)    _OpenWindow(INTUITION_BASE_NAME, newWindow)
  1475.  
  1476. static __inline struct Window *
  1477. _OpenWindow(void *IntuitionBase, struct NewWindow *newWindow)
  1478. {
  1479. struct Caos    MyCaos;
  1480.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1481. //    MyCaos.M68kStart    =    NULL;
  1482. //    MyCaos.M68kSize        =    0;
  1483.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1484. //    MyCaos.PPCStart        =    NULL;
  1485. //    MyCaos.PPCSize        =    0;
  1486.     MyCaos.a0        =(ULONG) newWindow;
  1487.     MyCaos.caos_Un.Offset    =    (-204);
  1488.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1489.     return((struct Window *)PPCCallOS(&MyCaos));
  1490. }
  1491.  
  1492. #define    OpenWindowTagList(newWindow, tagList)    _OpenWindowTagList(INTUITION_BASE_NAME, newWindow, tagList)
  1493.  
  1494. static __inline struct Window *
  1495. _OpenWindowTagList(void *IntuitionBase, struct NewWindow *newWindow, struct TagItem *tagList)
  1496. {
  1497. struct Caos    MyCaos;
  1498.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1499. //    MyCaos.M68kStart    =    NULL;
  1500. //    MyCaos.M68kSize        =    0;
  1501.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1502. //    MyCaos.PPCStart        =    NULL;
  1503. //    MyCaos.PPCSize        =    0;
  1504.     MyCaos.a0        =(ULONG) newWindow;
  1505.     MyCaos.a1        =(ULONG) tagList;
  1506.     MyCaos.caos_Un.Offset    =    (-606);
  1507.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1508.     return((struct Window *)PPCCallOS(&MyCaos));
  1509. }
  1510.  
  1511. #ifndef NO_PPCINLINE_STDARG
  1512. #define OpenWindowTags(a0, tags...) \
  1513.     ({ULONG _tags[] = { tags }; OpenWindowTagList((a0), (struct TagItem *)_tags);})
  1514. #endif /* !NO_PPCINLINE_STDARG */
  1515.  
  1516. #define    OpenWorkBench()    _OpenWorkBench(INTUITION_BASE_NAME)
  1517.  
  1518. static __inline ULONG
  1519. _OpenWorkBench(void *IntuitionBase)
  1520. {
  1521. struct Caos    MyCaos;
  1522.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1523. //    MyCaos.M68kStart    =    NULL;
  1524. //    MyCaos.M68kSize        =    0;
  1525.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1526. //    MyCaos.PPCStart        =    NULL;
  1527. //    MyCaos.PPCSize        =    0;
  1528.     MyCaos.caos_Un.Offset    =    (-210);
  1529.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1530.     return((ULONG)PPCCallOS(&MyCaos));
  1531. }
  1532.  
  1533. #define    PointInImage(point, image)    _PointInImage(INTUITION_BASE_NAME, point, image)
  1534.  
  1535. static __inline BOOL
  1536. _PointInImage(void *IntuitionBase, unsigned long point, struct Image *image)
  1537. {
  1538. struct Caos    MyCaos;
  1539.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1540. //    MyCaos.M68kStart    =    NULL;
  1541. //    MyCaos.M68kSize        =    0;
  1542.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1543. //    MyCaos.PPCStart        =    NULL;
  1544. //    MyCaos.PPCSize        =    0;
  1545.     MyCaos.d0        =(ULONG) point;
  1546.     MyCaos.a0        =(ULONG) image;
  1547.     MyCaos.caos_Un.Offset    =    (-624);
  1548.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1549.     return((BOOL)PPCCallOS(&MyCaos));
  1550. }
  1551.  
  1552. #define    PrintIText(rp, iText, left, top)    _PrintIText(INTUITION_BASE_NAME, rp, iText, left, top)
  1553.  
  1554. static __inline void
  1555. _PrintIText(void *IntuitionBase, struct RastPort *rp, struct IntuiText *iText, long left, long top)
  1556. {
  1557. struct Caos    MyCaos;
  1558.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1559. //    MyCaos.M68kStart    =    NULL;
  1560. //    MyCaos.M68kSize        =    0;
  1561.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1562. //    MyCaos.PPCStart        =    NULL;
  1563. //    MyCaos.PPCSize        =    0;
  1564.     MyCaos.a0        =(ULONG) rp;
  1565.     MyCaos.a1        =(ULONG) iText;
  1566.     MyCaos.d0        =(ULONG) left;
  1567.     MyCaos.d1        =(ULONG) top;
  1568.     MyCaos.caos_Un.Offset    =    (-216);
  1569.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1570.     PPCCallOS(&MyCaos);
  1571. }
  1572.  
  1573. #define    PubScreenStatus(screen, statusFlags)    _PubScreenStatus(INTUITION_BASE_NAME, screen, statusFlags)
  1574.  
  1575. static __inline UWORD
  1576. _PubScreenStatus(void *IntuitionBase, struct Screen *screen, unsigned long statusFlags)
  1577. {
  1578. struct Caos    MyCaos;
  1579.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1580. //    MyCaos.M68kStart    =    NULL;
  1581. //    MyCaos.M68kSize        =    0;
  1582.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1583. //    MyCaos.PPCStart        =    NULL;
  1584. //    MyCaos.PPCSize        =    0;
  1585.     MyCaos.a0        =(ULONG) screen;
  1586.     MyCaos.d0        =(ULONG) statusFlags;
  1587.     MyCaos.caos_Un.Offset    =    (-552);
  1588.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1589.     return((UWORD)PPCCallOS(&MyCaos));
  1590. }
  1591.  
  1592. #define    QueryOverscan(displayID, rect, oScanType)    _QueryOverscan(INTUITION_BASE_NAME, displayID, rect, oScanType)
  1593.  
  1594. static __inline LONG
  1595. _QueryOverscan(void *IntuitionBase, unsigned long displayID, struct Rectangle *rect, long oScanType)
  1596. {
  1597. struct Caos    MyCaos;
  1598.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1599. //    MyCaos.M68kStart    =    NULL;
  1600. //    MyCaos.M68kSize        =    0;
  1601.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1602. //    MyCaos.PPCStart        =    NULL;
  1603. //    MyCaos.PPCSize        =    0;
  1604.     MyCaos.a0        =(ULONG) displayID;
  1605.     MyCaos.a1        =(ULONG) rect;
  1606.     MyCaos.d0        =(ULONG) oScanType;
  1607.     MyCaos.caos_Un.Offset    =    (-474);
  1608.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1609.     return((LONG)PPCCallOS(&MyCaos));
  1610. }
  1611.  
  1612. #define    RefreshGList(gadgets, window, requester, numGad)    _RefreshGList(INTUITION_BASE_NAME, gadgets, window, requester, numGad)
  1613.  
  1614. static __inline void
  1615. _RefreshGList(void *IntuitionBase, struct Gadget *gadgets, struct Window *window, struct Requester *requester, long numGad)
  1616. {
  1617. struct Caos    MyCaos;
  1618.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1619. //    MyCaos.M68kStart    =    NULL;
  1620. //    MyCaos.M68kSize        =    0;
  1621.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1622. //    MyCaos.PPCStart        =    NULL;
  1623. //    MyCaos.PPCSize        =    0;
  1624.     MyCaos.a0        =(ULONG) gadgets;
  1625.     MyCaos.a1        =(ULONG) window;
  1626.     MyCaos.a2        =(ULONG) requester;
  1627.     MyCaos.d0        =(ULONG) numGad;
  1628.     MyCaos.caos_Un.Offset    =    (-432);
  1629.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1630.     PPCCallOS(&MyCaos);
  1631. }
  1632.  
  1633. #define    RefreshGadgets(gadgets, window, requester)    _RefreshGadgets(INTUITION_BASE_NAME, gadgets, window, requester)
  1634.  
  1635. static __inline void
  1636. _RefreshGadgets(void *IntuitionBase, struct Gadget *gadgets, struct Window *window, struct Requester *requester)
  1637. {
  1638. struct Caos    MyCaos;
  1639.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1640. //    MyCaos.M68kStart    =    NULL;
  1641. //    MyCaos.M68kSize        =    0;
  1642.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1643. //    MyCaos.PPCStart        =    NULL;
  1644. //    MyCaos.PPCSize        =    0;
  1645.     MyCaos.a0        =(ULONG) gadgets;
  1646.     MyCaos.a1        =(ULONG) window;
  1647.     MyCaos.a2        =(ULONG) requester;
  1648.     MyCaos.caos_Un.Offset    =    (-222);
  1649.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1650.     PPCCallOS(&MyCaos);
  1651. }
  1652.  
  1653. #define    RefreshWindowFrame(window)    _RefreshWindowFrame(INTUITION_BASE_NAME, window)
  1654.  
  1655. static __inline void
  1656. _RefreshWindowFrame(void *IntuitionBase, struct Window *window)
  1657. {
  1658. struct Caos    MyCaos;
  1659.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1660. //    MyCaos.M68kStart    =    NULL;
  1661. //    MyCaos.M68kSize        =    0;
  1662.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1663. //    MyCaos.PPCStart        =    NULL;
  1664. //    MyCaos.PPCSize        =    0;
  1665.     MyCaos.a0        =(ULONG) window;
  1666.     MyCaos.caos_Un.Offset    =    (-456);
  1667.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1668.     PPCCallOS(&MyCaos);
  1669. }
  1670.  
  1671. #define    ReleaseGIRPort(rp)    _ReleaseGIRPort(INTUITION_BASE_NAME, rp)
  1672.  
  1673. static __inline void
  1674. _ReleaseGIRPort(void *IntuitionBase, struct RastPort *rp)
  1675. {
  1676. struct Caos    MyCaos;
  1677.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1678. //    MyCaos.M68kStart    =    NULL;
  1679. //    MyCaos.M68kSize        =    0;
  1680.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1681. //    MyCaos.PPCStart        =    NULL;
  1682. //    MyCaos.PPCSize        =    0;
  1683.     MyCaos.a0        =(ULONG) rp;
  1684.     MyCaos.caos_Un.Offset    =    (-564);
  1685.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1686.     PPCCallOS(&MyCaos);
  1687. }
  1688.  
  1689. #define    RemakeDisplay()    _RemakeDisplay(INTUITION_BASE_NAME)
  1690.  
  1691. static __inline LONG
  1692. _RemakeDisplay(void *IntuitionBase)
  1693. {
  1694. struct Caos    MyCaos;
  1695.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1696. //    MyCaos.M68kStart    =    NULL;
  1697. //    MyCaos.M68kSize        =    0;
  1698.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1699. //    MyCaos.PPCStart        =    NULL;
  1700. //    MyCaos.PPCSize        =    0;
  1701.     MyCaos.caos_Un.Offset    =    (-384);
  1702.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1703.     return((LONG)PPCCallOS(&MyCaos));
  1704. }
  1705.  
  1706. #define    RemoveClass(classPtr)    _RemoveClass(INTUITION_BASE_NAME, classPtr)
  1707.  
  1708. static __inline void
  1709. _RemoveClass(void *IntuitionBase, struct IClass *classPtr)
  1710. {
  1711. struct Caos    MyCaos;
  1712.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1713. //    MyCaos.M68kStart    =    NULL;
  1714. //    MyCaos.M68kSize        =    0;
  1715.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1716. //    MyCaos.PPCStart        =    NULL;
  1717. //    MyCaos.PPCSize        =    0;
  1718.     MyCaos.a0        =(ULONG) classPtr;
  1719.     MyCaos.caos_Un.Offset    =    (-708);
  1720.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1721.     PPCCallOS(&MyCaos);
  1722. }
  1723.  
  1724. #define    RemoveGList(remPtr, gadget, numGad)    _RemoveGList(INTUITION_BASE_NAME, remPtr, gadget, numGad)
  1725.  
  1726. static __inline UWORD
  1727. _RemoveGList(void *IntuitionBase, struct Window *remPtr, struct Gadget *gadget, long numGad)
  1728. {
  1729. struct Caos    MyCaos;
  1730.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1731. //    MyCaos.M68kStart    =    NULL;
  1732. //    MyCaos.M68kSize        =    0;
  1733.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1734. //    MyCaos.PPCStart        =    NULL;
  1735. //    MyCaos.PPCSize        =    0;
  1736.     MyCaos.a0        =(ULONG) remPtr;
  1737.     MyCaos.a1        =(ULONG) gadget;
  1738.     MyCaos.d0        =(ULONG) numGad;
  1739.     MyCaos.caos_Un.Offset    =    (-444);
  1740.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1741.     return((UWORD)PPCCallOS(&MyCaos));
  1742. }
  1743.  
  1744. #define    RemoveGadget(window, gadget)    _RemoveGadget(INTUITION_BASE_NAME, window, gadget)
  1745.  
  1746. static __inline UWORD
  1747. _RemoveGadget(void *IntuitionBase, struct Window *window, struct Gadget *gadget)
  1748. {
  1749. struct Caos    MyCaos;
  1750.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1751. //    MyCaos.M68kStart    =    NULL;
  1752. //    MyCaos.M68kSize        =    0;
  1753.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1754. //    MyCaos.PPCStart        =    NULL;
  1755. //    MyCaos.PPCSize        =    0;
  1756.     MyCaos.a0        =(ULONG) window;
  1757.     MyCaos.a1        =(ULONG) gadget;
  1758.     MyCaos.caos_Un.Offset    =    (-228);
  1759.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1760.     return((UWORD)PPCCallOS(&MyCaos));
  1761. }
  1762.  
  1763. #define    ReportMouse(flag, window)    _ReportMouse(INTUITION_BASE_NAME, flag, window)
  1764.  
  1765. static __inline void
  1766. _ReportMouse(void *IntuitionBase, long flag, struct Window *window)
  1767. {
  1768. struct Caos    MyCaos;
  1769.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1770. //    MyCaos.M68kStart    =    NULL;
  1771. //    MyCaos.M68kSize        =    0;
  1772.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1773. //    MyCaos.PPCStart        =    NULL;
  1774. //    MyCaos.PPCSize        =    0;
  1775.     MyCaos.d0        =(ULONG) flag;
  1776.     MyCaos.a0        =(ULONG) window;
  1777.     MyCaos.caos_Un.Offset    =    (-234);
  1778.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1779.     PPCCallOS(&MyCaos);
  1780. }
  1781.  
  1782. #define    Request(requester, window)    _Request(INTUITION_BASE_NAME, requester, window)
  1783.  
  1784. static __inline BOOL
  1785. _Request(void *IntuitionBase, struct Requester *requester, struct Window *window)
  1786. {
  1787. struct Caos    MyCaos;
  1788.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1789. //    MyCaos.M68kStart    =    NULL;
  1790. //    MyCaos.M68kSize        =    0;
  1791.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1792. //    MyCaos.PPCStart        =    NULL;
  1793. //    MyCaos.PPCSize        =    0;
  1794.     MyCaos.a0        =(ULONG) requester;
  1795.     MyCaos.a1        =(ULONG) window;
  1796.     MyCaos.caos_Un.Offset    =    (-240);
  1797.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1798.     return((BOOL)PPCCallOS(&MyCaos));
  1799. }
  1800.  
  1801. #define    ResetMenuStrip(window, menu)    _ResetMenuStrip(INTUITION_BASE_NAME, window, menu)
  1802.  
  1803. static __inline BOOL
  1804. _ResetMenuStrip(void *IntuitionBase, struct Window *window, struct Menu *menu)
  1805. {
  1806. struct Caos    MyCaos;
  1807.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1808. //    MyCaos.M68kStart    =    NULL;
  1809. //    MyCaos.M68kSize        =    0;
  1810.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1811. //    MyCaos.PPCStart        =    NULL;
  1812. //    MyCaos.PPCSize        =    0;
  1813.     MyCaos.a0        =(ULONG) window;
  1814.     MyCaos.a1        =(ULONG) menu;
  1815.     MyCaos.caos_Un.Offset    =    (-702);
  1816.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1817.     return((BOOL)PPCCallOS(&MyCaos));
  1818. }
  1819.  
  1820. #define    RethinkDisplay()    _RethinkDisplay(INTUITION_BASE_NAME)
  1821.  
  1822. static __inline LONG
  1823. _RethinkDisplay(void *IntuitionBase)
  1824. {
  1825. struct Caos    MyCaos;
  1826.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1827. //    MyCaos.M68kStart    =    NULL;
  1828. //    MyCaos.M68kSize        =    0;
  1829.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1830. //    MyCaos.PPCStart        =    NULL;
  1831. //    MyCaos.PPCSize        =    0;
  1832.     MyCaos.caos_Un.Offset    =    (-390);
  1833.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1834.     return((LONG)PPCCallOS(&MyCaos));
  1835. }
  1836.  
  1837. #define    ScreenDepth(screen, flags, reserved)    _ScreenDepth(INTUITION_BASE_NAME, screen, flags, reserved)
  1838.  
  1839. static __inline void
  1840. _ScreenDepth(void *IntuitionBase, struct Screen *screen, unsigned long flags, APTR reserved)
  1841. {
  1842. struct Caos    MyCaos;
  1843.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1844. //    MyCaos.M68kStart    =    NULL;
  1845. //    MyCaos.M68kSize        =    0;
  1846.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1847. //    MyCaos.PPCStart        =    NULL;
  1848. //    MyCaos.PPCSize        =    0;
  1849.     MyCaos.a0        =(ULONG) screen;
  1850.     MyCaos.d0        =(ULONG) flags;
  1851.     MyCaos.a1        =(ULONG) reserved;
  1852.     MyCaos.caos_Un.Offset    =    (-786);
  1853.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1854.     PPCCallOS(&MyCaos);
  1855. }
  1856.  
  1857. #define    ScreenPosition(screen, flags, x1, y1, x2, y2)    _ScreenPosition(INTUITION_BASE_NAME, screen, flags, x1, y1, x2, y2)
  1858.  
  1859. static __inline void
  1860. _ScreenPosition(void *IntuitionBase, struct Screen *screen, unsigned long flags, long x1, long y1, long x2, long y2)
  1861. {
  1862. struct Caos    MyCaos;
  1863.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1864. //    MyCaos.M68kStart    =    NULL;
  1865. //    MyCaos.M68kSize        =    0;
  1866.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1867. //    MyCaos.PPCStart        =    NULL;
  1868. //    MyCaos.PPCSize        =    0;
  1869.     MyCaos.a0        =(ULONG) screen;
  1870.     MyCaos.d0        =(ULONG) flags;
  1871.     MyCaos.d1        =(ULONG) x1;
  1872.     MyCaos.d2        =(ULONG) y1;
  1873.     MyCaos.d3        =(ULONG) x2;
  1874.     MyCaos.d4        =(ULONG) y2;
  1875.     MyCaos.caos_Un.Offset    =    (-792);
  1876.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1877.     PPCCallOS(&MyCaos);
  1878. }
  1879.  
  1880. #define    ScreenToBack(screen)    _ScreenToBack(INTUITION_BASE_NAME, screen)
  1881.  
  1882. static __inline void
  1883. _ScreenToBack(void *IntuitionBase, struct Screen *screen)
  1884. {
  1885. struct Caos    MyCaos;
  1886.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1887. //    MyCaos.M68kStart    =    NULL;
  1888. //    MyCaos.M68kSize        =    0;
  1889.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1890. //    MyCaos.PPCStart        =    NULL;
  1891. //    MyCaos.PPCSize        =    0;
  1892.     MyCaos.a0        =(ULONG) screen;
  1893.     MyCaos.caos_Un.Offset    =    (-246);
  1894.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1895.     PPCCallOS(&MyCaos);
  1896. }
  1897.  
  1898. #define    ScreenToFront(screen)    _ScreenToFront(INTUITION_BASE_NAME, screen)
  1899.  
  1900. static __inline void
  1901. _ScreenToFront(void *IntuitionBase, struct Screen *screen)
  1902. {
  1903. struct Caos    MyCaos;
  1904.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1905. //    MyCaos.M68kStart    =    NULL;
  1906. //    MyCaos.M68kSize        =    0;
  1907.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1908. //    MyCaos.PPCStart        =    NULL;
  1909. //    MyCaos.PPCSize        =    0;
  1910.     MyCaos.a0        =(ULONG) screen;
  1911.     MyCaos.caos_Un.Offset    =    (-252);
  1912.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1913.     PPCCallOS(&MyCaos);
  1914. }
  1915.  
  1916. #define    ScrollWindowRaster(win, dx, dy, xMin, yMin, xMax, yMax)    _ScrollWindowRaster(INTUITION_BASE_NAME, win, dx, dy, xMin, yMin, xMax, yMax)
  1917.  
  1918. static __inline void
  1919. _ScrollWindowRaster(void *IntuitionBase, struct Window *win, long dx, long dy, long xMin, long yMin, long xMax, long yMax)
  1920. {
  1921. struct Caos    MyCaos;
  1922.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1923. //    MyCaos.M68kStart    =    NULL;
  1924. //    MyCaos.M68kSize        =    0;
  1925.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1926. //    MyCaos.PPCStart        =    NULL;
  1927. //    MyCaos.PPCSize        =    0;
  1928.     MyCaos.a1        =(ULONG) win;
  1929.     MyCaos.d0        =(ULONG) dx;
  1930.     MyCaos.d1        =(ULONG) dy;
  1931.     MyCaos.d2        =(ULONG) xMin;
  1932.     MyCaos.d3        =(ULONG) yMin;
  1933.     MyCaos.d4        =(ULONG) xMax;
  1934.     MyCaos.d5        =(ULONG) yMax;
  1935.     MyCaos.caos_Un.Offset    =    (-798);
  1936.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1937.     PPCCallOS(&MyCaos);
  1938. }
  1939.  
  1940. #define    SetAttrsA(object, tagList)    _SetAttrsA(INTUITION_BASE_NAME, object, tagList)
  1941.  
  1942. static __inline ULONG
  1943. _SetAttrsA(void *IntuitionBase, APTR object, struct TagItem *tagList)
  1944. {
  1945. struct Caos    MyCaos;
  1946.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1947. //    MyCaos.M68kStart    =    NULL;
  1948. //    MyCaos.M68kSize        =    0;
  1949.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1950. //    MyCaos.PPCStart        =    NULL;
  1951. //    MyCaos.PPCSize        =    0;
  1952.     MyCaos.a0        =(ULONG) object;
  1953.     MyCaos.a1        =(ULONG) tagList;
  1954.     MyCaos.caos_Un.Offset    =    (-648);
  1955.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1956.     return((ULONG)PPCCallOS(&MyCaos));
  1957. }
  1958.  
  1959. #ifndef NO_PPCINLINE_STDARG
  1960. #define SetAttrs(a0, tags...) \
  1961.     ({ULONG _tags[] = { tags }; SetAttrsA((a0), (struct TagItem *)_tags);})
  1962. #endif /* !NO_PPCINLINE_STDARG */
  1963.  
  1964. #define    SetDMRequest(window, requester)    _SetDMRequest(INTUITION_BASE_NAME, window, requester)
  1965.  
  1966. static __inline BOOL
  1967. _SetDMRequest(void *IntuitionBase, struct Window *window, struct Requester *requester)
  1968. {
  1969. struct Caos    MyCaos;
  1970.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1971. //    MyCaos.M68kStart    =    NULL;
  1972. //    MyCaos.M68kSize        =    0;
  1973.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1974. //    MyCaos.PPCStart        =    NULL;
  1975. //    MyCaos.PPCSize        =    0;
  1976.     MyCaos.a0        =(ULONG) window;
  1977.     MyCaos.a1        =(ULONG) requester;
  1978.     MyCaos.caos_Un.Offset    =    (-258);
  1979.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1980.     return((BOOL)PPCCallOS(&MyCaos));
  1981. }
  1982.  
  1983. #define    SetDefaultPubScreen(name)    _SetDefaultPubScreen(INTUITION_BASE_NAME, name)
  1984.  
  1985. static __inline void
  1986. _SetDefaultPubScreen(void *IntuitionBase, UBYTE *name)
  1987. {
  1988. struct Caos    MyCaos;
  1989.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1990. //    MyCaos.M68kStart    =    NULL;
  1991. //    MyCaos.M68kSize        =    0;
  1992.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1993. //    MyCaos.PPCStart        =    NULL;
  1994. //    MyCaos.PPCSize        =    0;
  1995.     MyCaos.a0        =(ULONG) name;
  1996.     MyCaos.caos_Un.Offset    =    (-540);
  1997.     MyCaos.a6        =(ULONG) IntuitionBase;    
  1998.     PPCCallOS(&MyCaos);
  1999. }
  2000.  
  2001. #define    SetEditHook(hook)    _SetEditHook(INTUITION_BASE_NAME, hook)
  2002.  
  2003. static __inline struct Hook *
  2004. _SetEditHook(void *IntuitionBase, struct Hook *hook)
  2005. {
  2006. struct Caos    MyCaos;
  2007.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2008. //    MyCaos.M68kStart    =    NULL;
  2009. //    MyCaos.M68kSize        =    0;
  2010.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2011. //    MyCaos.PPCStart        =    NULL;
  2012. //    MyCaos.PPCSize        =    0;
  2013.     MyCaos.a0        =(ULONG) hook;
  2014.     MyCaos.caos_Un.Offset    =    (-492);
  2015.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2016.     return((struct Hook *)PPCCallOS(&MyCaos));
  2017. }
  2018.  
  2019. #define    SetGadgetAttrsA(gadget, window, requester, tagList)    _SetGadgetAttrsA(INTUITION_BASE_NAME, gadget, window, requester, tagList)
  2020.  
  2021. static __inline ULONG
  2022. _SetGadgetAttrsA(void *IntuitionBase, struct Gadget *gadget, struct Window *window, struct Requester *requester, struct TagItem *tagList)
  2023. {
  2024. struct Caos    MyCaos;
  2025.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2026. //    MyCaos.M68kStart    =    NULL;
  2027. //    MyCaos.M68kSize        =    0;
  2028.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2029. //    MyCaos.PPCStart        =    NULL;
  2030. //    MyCaos.PPCSize        =    0;
  2031.     MyCaos.a0        =(ULONG) gadget;
  2032.     MyCaos.a1        =(ULONG) window;
  2033.     MyCaos.a2        =(ULONG) requester;
  2034.     MyCaos.a3        =(ULONG) tagList;
  2035.     MyCaos.caos_Un.Offset    =    (-660);
  2036.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2037.     return((ULONG)PPCCallOS(&MyCaos));
  2038. }
  2039.  
  2040. #ifndef NO_PPCINLINE_STDARG
  2041. #define SetGadgetAttrs(a0, a1, a2, tags...) \
  2042.     ({ULONG _tags[] = { tags }; SetGadgetAttrsA((a0), (a1), (a2), (struct TagItem *)_tags);})
  2043. #endif /* !NO_PPCINLINE_STDARG */
  2044.  
  2045. #define    SetMenuStrip(window, menu)    _SetMenuStrip(INTUITION_BASE_NAME, window, menu)
  2046.  
  2047. static __inline BOOL
  2048. _SetMenuStrip(void *IntuitionBase, struct Window *window, struct Menu *menu)
  2049. {
  2050. struct Caos    MyCaos;
  2051.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2052. //    MyCaos.M68kStart    =    NULL;
  2053. //    MyCaos.M68kSize        =    0;
  2054.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2055. //    MyCaos.PPCStart        =    NULL;
  2056. //    MyCaos.PPCSize        =    0;
  2057.     MyCaos.a0        =(ULONG) window;
  2058.     MyCaos.a1        =(ULONG) menu;
  2059.     MyCaos.caos_Un.Offset    =    (-264);
  2060.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2061.     return((BOOL)PPCCallOS(&MyCaos));
  2062. }
  2063.  
  2064. #define    SetMouseQueue(window, queueLength)    _SetMouseQueue(INTUITION_BASE_NAME, window, queueLength)
  2065.  
  2066. static __inline LONG
  2067. _SetMouseQueue(void *IntuitionBase, struct Window *window, unsigned long queueLength)
  2068. {
  2069. struct Caos    MyCaos;
  2070.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2071. //    MyCaos.M68kStart    =    NULL;
  2072. //    MyCaos.M68kSize        =    0;
  2073.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2074. //    MyCaos.PPCStart        =    NULL;
  2075. //    MyCaos.PPCSize        =    0;
  2076.     MyCaos.a0        =(ULONG) window;
  2077.     MyCaos.d0        =(ULONG) queueLength;
  2078.     MyCaos.caos_Un.Offset    =    (-498);
  2079.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2080.     return((LONG)PPCCallOS(&MyCaos));
  2081. }
  2082.  
  2083. #define    SetPointer(window, pointer, height, width, xOffset, yOffset)    _SetPointer(INTUITION_BASE_NAME, window, pointer, height, width, xOffset, yOffset)
  2084.  
  2085. static __inline void
  2086. _SetPointer(void *IntuitionBase, struct Window *window, UWORD *pointer, long height, long width, long xOffset, long yOffset)
  2087. {
  2088. struct Caos    MyCaos;
  2089.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2090. //    MyCaos.M68kStart    =    NULL;
  2091. //    MyCaos.M68kSize        =    0;
  2092.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2093. //    MyCaos.PPCStart        =    NULL;
  2094. //    MyCaos.PPCSize        =    0;
  2095.     MyCaos.a0        =(ULONG) window;
  2096.     MyCaos.a1        =(ULONG) pointer;
  2097.     MyCaos.d0        =(ULONG) height;
  2098.     MyCaos.d1        =(ULONG) width;
  2099.     MyCaos.d2        =(ULONG) xOffset;
  2100.     MyCaos.d3        =(ULONG) yOffset;
  2101.     MyCaos.caos_Un.Offset    =    (-270);
  2102.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2103.     PPCCallOS(&MyCaos);
  2104. }
  2105.  
  2106. #define    SetPrefs(preferences, size, inform)    _SetPrefs(INTUITION_BASE_NAME, preferences, size, inform)
  2107.  
  2108. static __inline struct Preferences *
  2109. _SetPrefs(void *IntuitionBase, struct Preferences *preferences, long size, long inform)
  2110. {
  2111. struct Caos    MyCaos;
  2112.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2113. //    MyCaos.M68kStart    =    NULL;
  2114. //    MyCaos.M68kSize        =    0;
  2115.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2116. //    MyCaos.PPCStart        =    NULL;
  2117. //    MyCaos.PPCSize        =    0;
  2118.     MyCaos.a0        =(ULONG) preferences;
  2119.     MyCaos.d0        =(ULONG) size;
  2120.     MyCaos.d1        =(ULONG) inform;
  2121.     MyCaos.caos_Un.Offset    =    (-324);
  2122.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2123.     return((struct Preferences *)PPCCallOS(&MyCaos));
  2124. }
  2125.  
  2126. #define    SetPubScreenModes(modes)    _SetPubScreenModes(INTUITION_BASE_NAME, modes)
  2127.  
  2128. static __inline UWORD
  2129. _SetPubScreenModes(void *IntuitionBase, unsigned long modes)
  2130. {
  2131. struct Caos    MyCaos;
  2132.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2133. //    MyCaos.M68kStart    =    NULL;
  2134. //    MyCaos.M68kSize        =    0;
  2135.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2136. //    MyCaos.PPCStart        =    NULL;
  2137. //    MyCaos.PPCSize        =    0;
  2138.     MyCaos.d0        =(ULONG) modes;
  2139.     MyCaos.caos_Un.Offset    =    (-546);
  2140.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2141.     return((UWORD)PPCCallOS(&MyCaos));
  2142. }
  2143.  
  2144. #define    SetWindowPointerA(win, taglist)    _SetWindowPointerA(INTUITION_BASE_NAME, win, taglist)
  2145.  
  2146. static __inline void
  2147. _SetWindowPointerA(void *IntuitionBase, struct Window *win, struct TagItem *taglist)
  2148. {
  2149. struct Caos    MyCaos;
  2150.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2151. //    MyCaos.M68kStart    =    NULL;
  2152. //    MyCaos.M68kSize        =    0;
  2153.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2154. //    MyCaos.PPCStart        =    NULL;
  2155. //    MyCaos.PPCSize        =    0;
  2156.     MyCaos.a0        =(ULONG) win;
  2157.     MyCaos.a1        =(ULONG) taglist;
  2158.     MyCaos.caos_Un.Offset    =    (-816);
  2159.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2160.     PPCCallOS(&MyCaos);
  2161. }
  2162.  
  2163. #ifndef NO_PPCINLINE_STDARG
  2164. #define SetWindowPointer(a0, tags...) \
  2165.     ({ULONG _tags[] = { tags }; SetWindowPointerA((a0), (struct TagItem *)_tags);})
  2166. #endif /* !NO_PPCINLINE_STDARG */
  2167.  
  2168. #define    SetWindowTitles(window, windowTitle, screenTitle)    _SetWindowTitles(INTUITION_BASE_NAME, window, windowTitle, screenTitle)
  2169.  
  2170. static __inline void
  2171. _SetWindowTitles(void *IntuitionBase, struct Window *window, UBYTE *windowTitle, UBYTE *screenTitle)
  2172. {
  2173. struct Caos    MyCaos;
  2174.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2175. //    MyCaos.M68kStart    =    NULL;
  2176. //    MyCaos.M68kSize        =    0;
  2177.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2178. //    MyCaos.PPCStart        =    NULL;
  2179. //    MyCaos.PPCSize        =    0;
  2180.     MyCaos.a0        =(ULONG) window;
  2181.     MyCaos.a1        =(ULONG) windowTitle;
  2182.     MyCaos.a2        =(ULONG) screenTitle;
  2183.     MyCaos.caos_Un.Offset    =    (-276);
  2184.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2185.     PPCCallOS(&MyCaos);
  2186. }
  2187.  
  2188. #define    ShowTitle(screen, showIt)    _ShowTitle(INTUITION_BASE_NAME, screen, showIt)
  2189.  
  2190. static __inline void
  2191. _ShowTitle(void *IntuitionBase, struct Screen *screen, long showIt)
  2192. {
  2193. struct Caos    MyCaos;
  2194.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2195. //    MyCaos.M68kStart    =    NULL;
  2196. //    MyCaos.M68kSize        =    0;
  2197.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2198. //    MyCaos.PPCStart        =    NULL;
  2199. //    MyCaos.PPCSize        =    0;
  2200.     MyCaos.a0        =(ULONG) screen;
  2201.     MyCaos.d0        =(ULONG) showIt;
  2202.     MyCaos.caos_Un.Offset    =    (-282);
  2203.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2204.     PPCCallOS(&MyCaos);
  2205. }
  2206.  
  2207. #define    SizeWindow(window, dx, dy)    _SizeWindow(INTUITION_BASE_NAME, window, dx, dy)
  2208.  
  2209. static __inline void
  2210. _SizeWindow(void *IntuitionBase, struct Window *window, long dx, long dy)
  2211. {
  2212. struct Caos    MyCaos;
  2213.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2214. //    MyCaos.M68kStart    =    NULL;
  2215. //    MyCaos.M68kSize        =    0;
  2216.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2217. //    MyCaos.PPCStart        =    NULL;
  2218. //    MyCaos.PPCSize        =    0;
  2219.     MyCaos.a0        =(ULONG) window;
  2220.     MyCaos.d0        =(ULONG) dx;
  2221.     MyCaos.d1        =(ULONG) dy;
  2222.     MyCaos.caos_Un.Offset    =    (-288);
  2223.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2224.     PPCCallOS(&MyCaos);
  2225. }
  2226.  
  2227. #define    SysReqHandler(window, idcmpPtr, waitInput)    _SysReqHandler(INTUITION_BASE_NAME, window, idcmpPtr, waitInput)
  2228.  
  2229. static __inline LONG
  2230. _SysReqHandler(void *IntuitionBase, struct Window *window, ULONG *idcmpPtr, long waitInput)
  2231. {
  2232. struct Caos    MyCaos;
  2233.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2234. //    MyCaos.M68kStart    =    NULL;
  2235. //    MyCaos.M68kSize        =    0;
  2236.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2237. //    MyCaos.PPCStart        =    NULL;
  2238. //    MyCaos.PPCSize        =    0;
  2239.     MyCaos.a0        =(ULONG) window;
  2240.     MyCaos.a1        =(ULONG) idcmpPtr;
  2241.     MyCaos.d0        =(ULONG) waitInput;
  2242.     MyCaos.caos_Un.Offset    =    (-600);
  2243.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2244.     return((LONG)PPCCallOS(&MyCaos));
  2245. }
  2246.  
  2247. #define    TimedDisplayAlert(alertNumber, string, height, time)    _TimedDisplayAlert(INTUITION_BASE_NAME, alertNumber, string, height, time)
  2248.  
  2249. static __inline BOOL
  2250. _TimedDisplayAlert(void *IntuitionBase, unsigned long alertNumber, UBYTE *string, unsigned long height, unsigned long time)
  2251. {
  2252. struct Caos    MyCaos;
  2253.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2254. //    MyCaos.M68kStart    =    NULL;
  2255. //    MyCaos.M68kSize        =    0;
  2256.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2257. //    MyCaos.PPCStart        =    NULL;
  2258. //    MyCaos.PPCSize        =    0;
  2259.     MyCaos.d0        =(ULONG) alertNumber;
  2260.     MyCaos.a0        =(ULONG) string;
  2261.     MyCaos.d1        =(ULONG) height;
  2262.     MyCaos.a1        =(ULONG) time;
  2263.     MyCaos.caos_Un.Offset    =    (-822);
  2264.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2265.     return((BOOL)PPCCallOS(&MyCaos));
  2266. }
  2267.  
  2268. #define    UnlockIBase(ibLock)    _UnlockIBase(INTUITION_BASE_NAME, ibLock)
  2269.  
  2270. static __inline void
  2271. _UnlockIBase(void *IntuitionBase, unsigned long ibLock)
  2272. {
  2273. struct Caos    MyCaos;
  2274.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2275. //    MyCaos.M68kStart    =    NULL;
  2276. //    MyCaos.M68kSize        =    0;
  2277.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2278. //    MyCaos.PPCStart        =    NULL;
  2279. //    MyCaos.PPCSize        =    0;
  2280.     MyCaos.a0        =(ULONG) ibLock;
  2281.     MyCaos.caos_Un.Offset    =    (-420);
  2282.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2283.     PPCCallOS(&MyCaos);
  2284. }
  2285.  
  2286. #define    UnlockPubScreen(name, screen)    _UnlockPubScreen(INTUITION_BASE_NAME, name, screen)
  2287.  
  2288. static __inline void
  2289. _UnlockPubScreen(void *IntuitionBase, UBYTE *name, struct Screen *screen)
  2290. {
  2291. struct Caos    MyCaos;
  2292.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2293. //    MyCaos.M68kStart    =    NULL;
  2294. //    MyCaos.M68kSize        =    0;
  2295.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2296. //    MyCaos.PPCStart        =    NULL;
  2297. //    MyCaos.PPCSize        =    0;
  2298.     MyCaos.a0        =(ULONG) name;
  2299.     MyCaos.a1        =(ULONG) screen;
  2300.     MyCaos.caos_Un.Offset    =    (-516);
  2301.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2302.     PPCCallOS(&MyCaos);
  2303. }
  2304.  
  2305. #define    UnlockPubScreenList()    _UnlockPubScreenList(INTUITION_BASE_NAME)
  2306.  
  2307. static __inline void
  2308. _UnlockPubScreenList(void *IntuitionBase)
  2309. {
  2310. struct Caos    MyCaos;
  2311.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2312. //    MyCaos.M68kStart    =    NULL;
  2313. //    MyCaos.M68kSize        =    0;
  2314.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2315. //    MyCaos.PPCStart        =    NULL;
  2316. //    MyCaos.PPCSize        =    0;
  2317.     MyCaos.caos_Un.Offset    =    (-528);
  2318.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2319.     PPCCallOS(&MyCaos);
  2320. }
  2321.  
  2322. #define    ViewAddress()    _ViewAddress(INTUITION_BASE_NAME)
  2323.  
  2324. static __inline struct View *
  2325. _ViewAddress(void *IntuitionBase)
  2326. {
  2327. struct Caos    MyCaos;
  2328.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2329. //    MyCaos.M68kStart    =    NULL;
  2330. //    MyCaos.M68kSize        =    0;
  2331.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2332. //    MyCaos.PPCStart        =    NULL;
  2333. //    MyCaos.PPCSize        =    0;
  2334.     MyCaos.caos_Un.Offset    =    (-294);
  2335.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2336.     return((struct View *)PPCCallOS(&MyCaos));
  2337. }
  2338.  
  2339. #define    ViewPortAddress(window)    _ViewPortAddress(INTUITION_BASE_NAME, window)
  2340.  
  2341. static __inline struct ViewPort *
  2342. _ViewPortAddress(void *IntuitionBase, struct Window *window)
  2343. {
  2344. struct Caos    MyCaos;
  2345.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2346. //    MyCaos.M68kStart    =    NULL;
  2347. //    MyCaos.M68kSize        =    0;
  2348.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2349. //    MyCaos.PPCStart        =    NULL;
  2350. //    MyCaos.PPCSize        =    0;
  2351.     MyCaos.a0        =(ULONG) window;
  2352.     MyCaos.caos_Un.Offset    =    (-300);
  2353.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2354.     return((struct ViewPort *)PPCCallOS(&MyCaos));
  2355. }
  2356.  
  2357. #define    WBenchToBack()    _WBenchToBack(INTUITION_BASE_NAME)
  2358.  
  2359. static __inline BOOL
  2360. _WBenchToBack(void *IntuitionBase)
  2361. {
  2362. struct Caos    MyCaos;
  2363.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2364. //    MyCaos.M68kStart    =    NULL;
  2365. //    MyCaos.M68kSize        =    0;
  2366.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2367. //    MyCaos.PPCStart        =    NULL;
  2368. //    MyCaos.PPCSize        =    0;
  2369.     MyCaos.caos_Un.Offset    =    (-336);
  2370.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2371.     return((BOOL)PPCCallOS(&MyCaos));
  2372. }
  2373.  
  2374. #define    WBenchToFront()    _WBenchToFront(INTUITION_BASE_NAME)
  2375.  
  2376. static __inline BOOL
  2377. _WBenchToFront(void *IntuitionBase)
  2378. {
  2379. struct Caos    MyCaos;
  2380.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2381. //    MyCaos.M68kStart    =    NULL;
  2382. //    MyCaos.M68kSize        =    0;
  2383.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2384. //    MyCaos.PPCStart        =    NULL;
  2385. //    MyCaos.PPCSize        =    0;
  2386.     MyCaos.caos_Un.Offset    =    (-342);
  2387.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2388.     return((BOOL)PPCCallOS(&MyCaos));
  2389. }
  2390.  
  2391. #define    WindowLimits(window, widthMin, heightMin, widthMax, heightMax)    _WindowLimits(INTUITION_BASE_NAME, window, widthMin, heightMin, widthMax, heightMax)
  2392.  
  2393. static __inline BOOL
  2394. _WindowLimits(void *IntuitionBase, struct Window *window, long widthMin, long heightMin, unsigned long widthMax, unsigned long heightMax)
  2395. {
  2396. struct Caos    MyCaos;
  2397.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2398. //    MyCaos.M68kStart    =    NULL;
  2399. //    MyCaos.M68kSize        =    0;
  2400.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2401. //    MyCaos.PPCStart        =    NULL;
  2402. //    MyCaos.PPCSize        =    0;
  2403.     MyCaos.a0        =(ULONG) window;
  2404.     MyCaos.d0        =(ULONG) widthMin;
  2405.     MyCaos.d1        =(ULONG) heightMin;
  2406.     MyCaos.d2        =(ULONG) widthMax;
  2407.     MyCaos.d3        =(ULONG) heightMax;
  2408.     MyCaos.caos_Un.Offset    =    (-318);
  2409.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2410.     return((BOOL)PPCCallOS(&MyCaos));
  2411. }
  2412.  
  2413. #define    WindowToBack(window)    _WindowToBack(INTUITION_BASE_NAME, window)
  2414.  
  2415. static __inline void
  2416. _WindowToBack(void *IntuitionBase, struct Window *window)
  2417. {
  2418. struct Caos    MyCaos;
  2419.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2420. //    MyCaos.M68kStart    =    NULL;
  2421. //    MyCaos.M68kSize        =    0;
  2422.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2423. //    MyCaos.PPCStart        =    NULL;
  2424. //    MyCaos.PPCSize        =    0;
  2425.     MyCaos.a0        =(ULONG) window;
  2426.     MyCaos.caos_Un.Offset    =    (-306);
  2427.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2428.     PPCCallOS(&MyCaos);
  2429. }
  2430.  
  2431. #define    WindowToFront(window)    _WindowToFront(INTUITION_BASE_NAME, window)
  2432.  
  2433. static __inline void
  2434. _WindowToFront(void *IntuitionBase, struct Window *window)
  2435. {
  2436. struct Caos    MyCaos;
  2437.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2438. //    MyCaos.M68kStart    =    NULL;
  2439. //    MyCaos.M68kSize        =    0;
  2440.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2441. //    MyCaos.PPCStart        =    NULL;
  2442. //    MyCaos.PPCSize        =    0;
  2443.     MyCaos.a0        =(ULONG) window;
  2444.     MyCaos.caos_Un.Offset    =    (-312);
  2445.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2446.     PPCCallOS(&MyCaos);
  2447. }
  2448.  
  2449. #define    ZipWindow(window)    _ZipWindow(INTUITION_BASE_NAME, window)
  2450.  
  2451. static __inline void
  2452. _ZipWindow(void *IntuitionBase, struct Window *window)
  2453. {
  2454. struct Caos    MyCaos;
  2455.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2456. //    MyCaos.M68kStart    =    NULL;
  2457. //    MyCaos.M68kSize        =    0;
  2458.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2459. //    MyCaos.PPCStart        =    NULL;
  2460. //    MyCaos.PPCSize        =    0;
  2461.     MyCaos.a0        =(ULONG) window;
  2462.     MyCaos.caos_Un.Offset    =    (-504);
  2463.     MyCaos.a6        =(ULONG) IntuitionBase;    
  2464.     PPCCallOS(&MyCaos);
  2465. }
  2466.  
  2467. #endif /* SASC Pragmas */
  2468. #endif /* !_PPCPRAGMA_INTUITION_H */
  2469.